Thread: Iterating over an array of C++ in a for loop

​Thank you for your precious time.

With my limited understanding of C++, it seems that instead of directly defining an array of C++ functions, we need an array of pointers to functions.

This is the only way I know how to use a for loop in C++ to iterate over a family of functions. I am creating a map from the names of functions to functions as follows:

Code:

map<string,void (*)(string, vector<string> &, vector<vector<RAStruct > > &  ) >map_FuncNamesToFuncs;

And once this map above is prepared and populated, finally I am able to iterate over the functionswith a for loop like this:

Code:

      vector<string>::iterator end = vec_NamesOfAverageFunctions.end() ;
      for(vector<string>::iterator itr=vec_NamesOfAverageFunctions.begin() ; itr != end; ++itr) {
         // map_FuncNamesToFuncs[ (*itr) ](  vec_NamesOfKeyFilesForRandAcc[i] , vec_CoreSymbolInfo, vec_NamesOfSymbolFilesForMarkets[i] )  ;
         map_FuncNamesToFuncs[ (*itr) ](   vec_NamesOfSymbolFilesForMarkets[i], vec_MarketSymbolList, vec_AllSymRecs   )  ;
         cout << "Executed avg function " << *itr  << endl;


      }

This works, but if there is a better way to access a family of functions, please let me know. In this case, the names of the functions that will be called can be written in a text file and the program that reads the text file can actually enable the map accordingly.

Thanks!!

I would reach for a typedef, e.g.,

Code:

typedef void (*AverageFunction)(std::string, std::vector<std::string>&, std::vector<std::vector<RAStruct>>&);

Now you can write:

Code:

map<string, AverageFunction> map_FuncNamesToFuncs;
// ...

for (const auto& functionName : vec_NamesOfAverageFunctions) {
    map_FuncNamesToFuncs[functionName](vec_NamesOfSymbolFilesForMarkets[i], vec_MarketSymbolList, vec_AllSymRecs);
    cout << "Executed avg function " << functionName << endl;
}

Originally Posted by FortranLevelC++

does C++ absolutely guarantee that when we use such a range-based for loop, the elements of the array or map of functions will be accessed/called in the same order as the original array/map was defined?

No, it will be accessed as if you looped over the container with a forward iterator. This does not necessarily correspond with how you populated the container, e.g., a std::set likely uses a balanced binary tree internal representation, so when accessing it with a forward iterator you likely will get the elements in sorted order unrelated to insertion order, and then a std::unordered_set is likely to be, well, unordered due to the hash table representation, yet also unrelated to insertion order.

Originally Posted by laserlight

No, it will be accessed as if you looped over the container with a forward iterator. This does not necessarily correspond with how you populated the container, e.g., a std::set likely uses a balanced binary tree internal representation, so when accessing it with a forward iterator you likely will get the elements in sorted order unrelated to insertion order, and then a std::unordered_set is likely to be, well, unordered due to the hash table representation, yet also unrelated to insertion order.

Of course, in the case of an unordered std::set, there would not be any consistent order in which the for loop accesses the elements.
But at least in my program where there is only a map of functions, when these functions are executed in the for loop that uses iterators,
it seems that the execution order is the same as the order in which the map of functions was populated. Maybe I was just lucky.
I will have to double check this because some functions depend on the result of the previous function call.

Anyway, I am very pleased with the rate at which C++ is being upgraded: maybe in a few years C++
will become more like Scala, at least for composing functions and building arrays of functions.

Originally Posted by FortranLevelC++

it seems that the execution order is the same as the order in which the map of functions was populated. Maybe I was just lucky.
I will have to double check this because some functions depend on the result of the previous function call.

I don't see how that matters: you populate the map, and then later you access its elements by function name to make the function calls. Hence, the order in which the map is populated should not matter. What matters is the order in which you use the function names to access the map so as to call the functions, and this is determined by the vector of names.