How can I tell when I've reached the end of an array?

[Drew88]

Ok, for my first post, here goes:

I'm working on an assignment for school that states:

Write a function that receives two one-dinemsional arrays that correspond to the flight-path angles and the corresponding coefficients of lift. The function should sort the flight-path angles into ascending order while maiantaing the correspondence between the flight-path angles and the corresponding coefficients of lift. Assume that the corresponding function prototype is:
void reorder(double& x, double& y);

Using this prototype and the way in which I call it, I think I'm just sending the values of the first element in each array, which I guess is fine. After I pass them to the call function, I read all the values in the original two arrays into two new arrays by incrementing the memory values and then dereferencing the memory values (You'll probably be able to understand much better when you see the code).

My problem is, my loops don't know when to stop reading values into the two new arrays, and I just put in some arbitrary conditions to make the loops stop, which aren't a complete colution.

How can I make the loops "know" when they've read all the values into the new arrays?

Thank you very much.

My code is as follows:

#include "stdafx.h"
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

const int n=100;
void reorder(double& x, double& y);

int _tmain(int argc, _TCHAR* argv[])
{
ifstream flight, coef;
string filename1, filename2;
double temp(0), temp2(0), temp5(0);
int npts(0), npts2(0), j(0), k(0);
double f[n], c[n];


count << "Enter the name of the file that contains the flight-path angles: ";
cin >> filename1;

flight.open(filename1.c_str());

if (flight.fail())
{
cerr << "ERROR OPENING FILE " << filename1 << "." << endl;
}

count << "\nEnter the name of the file that contains the coefficients of lift: ";
cin >> filename2;

coef.open(filename2.c_str());

if (coef.fail())
{
cerr << "ERROR OPENING FILE " << filename2 << "." << endl;
}

flight >> temp;

while (npts < n && !flight.eof())
{
f[npts] = temp;

flight >> temp;

++npts;
}

coef >> temp2;

while (npts2 < n && !coef.eof())
{
c[npts2] = temp2;

coef >> temp2;

++npts2;
}

reorder(*f, *c);

count << "\nThis is now the final order:";
for (int b=0; b<npts2; b++)
{
count << "\n" << f << " " << c;
}

return 0;
}


void reorder(double& x, double& y)
{
const int n=100;
int npts(0), npts2(0), j(0), k(0), h(0), g(0);
double temp(0), temp2(0), temp5(0), f[n], c[n];
double * p;
p = &x;
double * u;
u = &y;

//Here is where the two loops are that read the data into two new arrays.
//As you can see, 20 and -1000 are randomly chosen values to make the loops
//break.
while (npts < 20 && *(p+h) > -1000)
{
f[h] = *(p+h);
npts = npts + 1;
h++;
}

while (npts2 < 20 && *(u+g) > -1000)
{
c[g] = *(u+g);
npts2 = npts2 + 1;
g++;
}

for (j=0; j<(npts-2); j++)
{
for(k=0; k<(npts2-1); k++)
{

if (f[k+1] < f[k])
{
temp5 = c[k];
c[k] = c[k+1];
c[k+1] = temp5;
}

double temp1(0), temp2(0);

temp1 = f[k];
temp2 = f[k+1];

if (temp1 <= temp2)
{
f[k] = temp1;
f[k+1] = temp2;
}

else
{
f[k] = temp2;
f[k+1] = temp1;
}
}
}

for (int b=0; b<npts2; b++)
{
*(p+b) = f;
*(u+b) = c;
}

return;
}

 

[jtbell]

After you've read all the data from the input file, store a "sentinel" value in the array after the final "real data" value. This should be some value that cannot occur as a legitimate data value. Then when you loop through the array to extract data, stop looping when you reach the sentinel.

For example, if your data consists of angles that range from 0 to 360 degrees, your sentinel might be -1, or 361, or 1000, or...