Loop through array of unknown size C++

12,664

Solution 1

In C++ operator sizeof is a compile-time operator. That is its value is calculated by the compiler not at run-time.

So if as you say the array has unknown size then the compiler can not calculate the size of the memory occupied by the array.

So it is evident that anArray is pointer to first element of the array that you might pass to the function.

Thus this expression

sizeof(anArray)/sizeof(double)

is equivalent to expression

sizeof( double * )/sizeof( double ).

You have to pass also the size of the array explicitly to the function.

Take into account that an array passed by value to a function is converted to pointer to its first element.

Or the other approach is to use conteiner std::vector<double>instead of the arrays.

You could declare your function like

stock_data max_profit(double price_array[], size_t size );

and call it like

 stock_data data = max_profit( yesterday, 
                               sizeof( yesterday ) / sizeof( *yesterday ) );

Solution 2

sizeof(anArray) returns the size of the type anArray, probably *double. You have to pass the array size as an additional parameter or use std::vector and it's size method.

Have a look at the C main function main(argc, argv) where argv are the parameters of the program and argc is their count. Or take strings, their end is determined by a special character \0 that determines its end. But that's error prone.

In C/C++ there is no other way with arrays.

Solution 3

If you really want to avoid passing the size, you can add a NaN at the end of the array and check for it in the loop.

#include<cmath>
...
for(int i = 0; !isnan(price_array[i]; i++){
    ...
}

To add the NaN when you're declaring the array:

double price_array{0.0d, 5.9d, nan()};

Of course, this assumes you won't have any other NaNs in your array as part of the actual data.

Solution 4

Your function max_profit does not know the size of the array price_array. If you want the function to accept arrays of varying size, you have two options:

  • Pass the size value alongside the array (C style)
  • Use std::vector object which holds the size inside (C++ style)
Share:
12,664
Mike B
Author by

Mike B

Updated on June 04, 2022

Comments

  • Mike B
    Mike B almost 2 years

    I am trying to traverse a double array of an unknown size.

    Why does the following not work?

    for (unsigned int = 1; i < sizeof(anArray)/sizeof(double); i++) {
        ...
    }
    

    Everything compiles fine (g++ -Wall -Werror -std=c++11 app.cpp -o app), but the program simply does not even enter the loop.

    Full function:

    struct stock_data {
       int sell_index;
       int buy_index;
       double profit;
    };
    
    stock_data max_profit(double price_array[]) {
       int sell_index = -1, buy_index = -1, 
          min = 0;
    
       double profit = 0.0;
    
       for(int i = 1; i < size; i++) {
    
          if(price_array[i] - price_array[min] > profit) {
             sell_index = min;
             buy_index = i;
             profit = price_array[i] - price_array[min];
          }
    
          if(price_array[i] < price_array[min]) {
            min = i;
          }
       }  
    
       return {sell_index, buy_index, profit};
    }
    
    int main() {
       double yesterday[] = {0.1, 0.2, 0.3, 0.4};
       stock_data data = max_profit(yesterday);
       cout << data.profit << endl;
    }
    
  • Cole Tobin
    Cole Tobin about 9 years
    Or use std::array or std::vector
  • Vlad from Moscow
    Vlad from Moscow about 9 years
    @Cole Johnson Initially he wrote in his post that he deals with arrays of unknown sizes. So I did not suggest to use std::array because its size also shall be known at compile time.
  • Cole Tobin
    Cole Tobin about 9 years
    std::vector OTOH, is dynamic and does not need a size specified at compile time
  • Vlad from Moscow
    Vlad from Moscow about 9 years
    @Cole Johnson I said about std::array.