the program stops on the 10th turn of a for. c ++

If you debug your program step by step, the problem would be obvious to you. I advise you to do it as a didactic exercise. Meanwhile, I explain the problem:

Arrangements.

• Arrays are a memory space that stores objects of the same type. They are defined this way: tipo nombre[tamaño] , you have an arrangement of type atleta declared like this:

  atleta at[10];
  

• Fixes in C ++ are indexed from 0 , so at[0] corresponds to the first position, at[1] to the second, at[2] to the third, and so on.
• Fixes in C ++ are stored in contiguous memory, this implies that between the start of at[0] and the beginning of at[1] there will be a number of bits equivalent to sizeof(atleta) since atleta is the type of the data stored in the at fix.
• C ++ does not check limits on fixes, so it is possible to access elements that do not correspond to those managed by the fix.
• Although in C ++ it is possible to access elements outside the limits of the array, doing so can cause the program to throw errors at run time.

Your arrangement.

You have an arrangement of 10 atleta :

atleta at[10];

That in memory will look like this:

As you can see, you have a variable called at that points to the beginning of 10 contiguous elements (count them, they are exactly 10, even if they start at 0 and end at 9).

Your code.

  

All that happened after you changed all the initial values of each for from 0 to 1

     

for (i=0 ; i<10 ; i++)  ------>>   for (i=1 ; i<11 ; i++)

  

Originally you went through the arrangement of the position 0 to the position 9 (since the value 10 violates the condition <10 ) and as those are exactly the positions that your arrangement has at everything worked correctly.

With the new change you go through the arrangement of the position 1 (which is the second position of the array) to the position 10 (which does not exist as the positions reach up to 9 ).

Trying to work with the 10 position (which is not assigned to the at fix) causes the program to fail at run time.

Other things to consider.

• You have misspellings.

• In C ++ the keyword struct is not part of the type, so it is not necessary to define variables of type struct :

     /*struct*/ atleta at[10];
  // ~~~~~~~~~~ <-- innecesario!
  

• C headers adapted to C ++ have no extension and have the prefix " c ", so <stdio.h> , <stdlib.h> and <math.h> would be <cstdio> , <cstdlib> and <cmath> (see this question for more details).
• You do not need the C headers that you are including, even if you included them correctly (which has not been the case, see previous point).

  

All that happened after changing all the initial values of each for from 0 to 1

The indexes start always at 0 ... Why then endeavor to reinvent the wheel and start them at 1?

If you make that change you have to change all the accesses to the vector:

at[i]   // MAL!!!!!
at[i-1] // BIEN

If you do not do this, two things happen:

So, I suggest you do yourself a favor and get used to traversing the vectors in the range (0..n-1) instead of the range (1..n). You will get your code compatible with that of 100% of the programmers who know how to do things.

And already speaking we talk about your code:

¿??

This code does not make any sense:

for (k=1;k<2;k++)
{
    op=0;
    cout<<endl<<endl<<"Indique su opcion: ";    cin>>op;
    if(op<=0)
    {
        //system ("cls");
        cout<<endl<<"Indique una opcion valida1";
        k--;

    }
    else
    {

    }
}

Your idea is to iterate until the user enters a valid option ... for that there exists while whose translation while is more appropriate to this context. For the benefit of your own health, try to make the code as legible as possible:

do
{
  cout<<endl<<endl<<"Indique su opcion: ";
  cin>>op;
  if(op<=0)
    cout<<endl<<"Indique una opcion valida\n";
} while( op <= 0 );

Do not mix buffers

In your program you are using the libraries iostream and stdio.h . The first one is typical of C ++ and the second one reminiscent to maintain some compatibility with C ... but you should not use it .

One of the reasons that many gurus that are learning to justify that C is much faster than C ++ is that the reading of data in C ++ is very slow ... well this is because, just by keeping stdio.h , it forces both systems to be synchronized ... which creates an overexertion in the C ++ layer ... however what these gurus do not know is that this synchronization it can be disabled ... allowing readings in C ++ to be faster than those in C.

std::ios_base::sync_with_stdio(false); // Para desincronizar los streams

The readings with iostream are much safer because they have the advantage of being typed ... which does not happen with the proper functions of C. This feature makes the compiler can warn you about certain aberrations or misconceptions .. .C functions will not show warnings and you will find the error when executing the application.

Now, as this option exists and someone can activate it at any time, it does not seem a good idea to base the good work of your program on the assumption that this does not exist or will never be done.

To read a line from the console, think something like this:

std::string s;
std::getline(std::cin, s);

Instead of

gets (at[i].n);

Likewise, consider using std::string instead of char[] .

fflush is not for inbound streams

fflush is intended to run on output devices and is indicated in the documentation :

  

In all other cases, the behavior depends on the specific library implementation. In some implementations, flushing a stream open for reading causes its input buffer to be cleared ( but this is not portable expected behavior ).

That is:

  

In all other cases, the behavior will depend on the implementation of the library. In some implementations, calling fflush for a stream reading results in emptying it (but it is not a portable behavior).

So, avoid this:

fflush(stdin);

To clean the input buffer in C ++ use this:

#include <limits>

std::cin.ignore(std::numeric_limits<int>::max(),'\n');

This function eliminates all of them until a line break ('\ n') is found, which will also be deleted ... or the input buffer will be completely emptied.

And well, there would be more things but we will leave it for another day, otherwise there will not be anyone who will read this answer.

When you have a menu of options, it is best to use a do {options menu} while (condition here);

And if before it worked for you because you did not leave it as it was?, I recommend you validate errors with try catch if possible in c because usually I only know Java. Remember that when something works do not touch it. and it is possible that your problem is based on that since they are 10, you start from 1 and not from 0 to 10, maybe you have to put for (int i = 1, i < = 10; i ++) {your codes here} Etc .. test the problem between counters and accumulators is always usually initialization.

After the line that says cout<<endl<<"A continuacion indique los 5 lanzamientos del atleta"; , you make a for where c1 goes from 1 to 5, but you are trying to go through the array l which has 5 elements, but the elements of an array do not begin to be enumerated from 1 but from scratch. You must be careful with those things. It seems that the exceptions caused by trying to access a registry of invalid RAM is what stops your program.