is there a way to call a function depending on an integer at runtime?

[aaragon]

I have this scenario: several arrays for which I have their fixed
values at compilation time. Now, at runtime I need to access a
specific array depending on an integer but I want to avoid if and
switch statements.

My first approach was to rely on partial template specialization.
Therefore, I have:

// .h file
template <int vSomeClass;

template <struct SomeClass<1{
static double loc(unsigned short i) {
return loc_[i];
}
static const double loc_[1];
};
template <struct SomeClass<2{
static double loc(unsigned short i) {
return loc_[i];
}
static const double loc_[2];
};
// and so on until 30 partial specializations

// .cpp file
const double SomeClass<1>::l oc_[] = { 0.4 };
const double SomeClass<2>::l oc_[] = { 0.2, 0.6 };
// and so on until 30 partial specializations

so I called the function like this:

double location = SomeClass<3>::l oc(2);

Well, this approach worked fine until I changed the code so that the
integer is not known until runtime. So the question is...
Is there a way to do the same at runtime without having a switch or if
statement? Is there a way to do function overloading at runtime? I
thought that I could have something like the following:

struct SomeClass {

int val;
SomeClass(int v) : val(v) {}

double loc(unsigned short i) {
return locImpl(classB( val),i);
}
double locImpl(classB( 1), int i) {
const double SomeClass<1>::l oc_[] = { 0.4};
return loc_[i];
}
double locImpl(classB( 2), int i) {
const double SomeClass<2>::l oc_[] = { 0.2, 0.6 };
return loc_[i];
}
};

and convert the integer to some class and rely on function
overloading, but I couldn't find a way to do this. Any ideas? Thank
you,

a²

[fl]

On 29 déc, 15:09, aaragon <alejandro.ara. [e-mail] te:

On Dec 29, 10:52 am, "Daniel T." <danie...@earth link.netwrote:

aaragon <alejandro.ara. [e-mail] te:

The problem with using a map is that it needs to be instantiated
with every element in it (all vectors needed to be created). I
wanted to use a function because in that way only the vectors that
I use are initialized. Most likely, I will be using only 1 of those
30 vectors for each run, so it doesn't make sense to initialize ALL
of them.

Unless a single run is extremely fast, and you will be running this
program thousands of times per second, the extra time it take to
initialize all of the vectors is irrelevant. And if the run is extremely
fast and you are running the program thousands of times per second, then
you should be embedding this code in a program that makes several passes
per run.

So yes, it does make sense to initialize all of them.

Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to function
pointers. Inside those functions the arrays (known at compilation
time) are declared static so they're initialized only once (when I
call the function the first time). In this way, I don't need to
initialize what I won't use. Also, I don'tneed to have annoying switch
or if blocks. It looks like this:

// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on

template <
class MapPolicy = std::map<size_t , double (*)(size_t)>

struct Map {

* typedef MapPolicy MapType;
* MapType loc_;

* Map() : loc_() {
* // add location function pointers
* loc_[1] = &loc<1>; * *// ERROR!!!
* loc_[2] = &loc<2>; * *// ERROR!!!
* // and so on
* }
* inline double loc(size_t i, size_t gp) {
* * return loc_[gp](i);
* }

};

// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
* static const double loc[] = { 0.4 };
* return loc[i];}

template<>
double loc<2>(size_t i) {
* static const double loc[] = { 0.2, 0.6 };
* return loc[i];}

// and so on until 30

Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code. At
those ERROR lines I have the following message:

testMap.h: In constructor 'fea::Map<MapPo licy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token

It doesn't allow me to take the address of the templated function. The
strange thing is that I can do the same from the main.cxx file, that
is:

// main.cxx

* * std::map<size_t , double (*)(size_t)loca tion;

* * location[1] = &loc<1>;
* * location[2] = &loc<2>;

* * cout<<"what the -"<<location[2](1)<<endl;

works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I know...
I could just use regular functions and call them loc1, loc2 and so on
and forget about the template (this will definitely work), but hey,
I'm learning day by day and I just cannot give up that easily, right?

a²- Masquer le texte des messages précédents -

- Afficher le texte des messages précédents -

Hi,
I get the following error message. Why? What's wrong with me? Thanks.

error C2039:'map' is not a member of 'std'
----------------
// .h file
#include <iostream>

template <int vdouble loc(size_t); // forward declarations of
function specializations (defined in .cxx file)
template <double loc<1>(size_t);
template <double loc<2>(size_t); // and so on
------------
#include <iostream>
#include "SomeClass. h"
using std::cout;
using std::endl;

int main()
{
std::map<size_t , double (*)(size_t)loca tion;

location[1] = &loc<1>;
location[2] = &loc<2>;
cout<<"using loc<1>: "<<loc<1>(1)<<e ndl;

return 0;
}

[aaragon]

On Dec 29, 7:56 pm, fl <rxjw...@gmail. comwrote:

On 29 déc, 15:09, aaragon <alejandro.ara. [e-mail] te:

On Dec 29, 10:52 am, "Daniel T." <danie...@earth link.netwrote:

aaragon <alejandro.ara. [e-mail] te:
The problem with using a map is that it needs to be instantiated
with every element in it (all vectors needed to be created). I
wanted to use a function because in that way only the vectors that
I use are initialized. Most likely, I will be using only 1 of those
30 vectors for each run, so it doesn't make sense to initialize ALL
of them.

Unless a single run is extremely fast, and you will be running this
program thousands of times per second, the extra time it take to
initialize all of the vectors is irrelevant. And if the run is extremely
fast and you are running the program thousands of times per second, then
you should be embedding this code in a program that makes several passes
per run.

So yes, it does make sense to initialize all of them.

Ok, so I decided to follow your advice but with a little twist.
Instead of having a map to a vector, I will have now a map to function
pointers. Inside those functions the arrays (known at compilation
time) are declared static so they're initialized only once (when I
call the function the first time). In this way, I don't need to
initialize what I won't use. Also, I don'tneed to have annoying switch
or if blocks. It looks like this:

// .h file
template <int v>
double loc(size_t);
// forward declarations of function specializations (defined in .cxx
file)
template <>
double loc<1>(size_t);
template <>
double loc<2>(size_t);
// and so on

template <
class MapPolicy = std::map<size_t , double (*)(size_t)>

struct Map {

typedef MapPolicy MapType;
MapType loc_;

Map() : loc_() {
// add location function pointers
loc_[1] = &loc<1>; // ERROR!!!
loc_[2] = &loc<2>; // ERROR!!!
// and so on
}
inline double loc(size_t i, size_t gp) {
return loc_[gp](i);
}

};

// .cxx file, partial specializations for the function
template<>
double loc<1>(size_t i) {
static const double loc[] = { 0.4 };
return loc[i];}

template<>
double loc<2>(size_t i) {
static const double loc[] = { 0.2, 0.6 };
return loc[i];}

// and so on until 30

Ok, this looks good and it's just what I want. However, for some
strange reason that I really don't see, I cannot compile this code. At
those ERROR lines I have the following message:

testMap.h: In constructor 'fea::Map<MapPo licy>::Map()':
testMap.h:36: error: expected primary-expression before ';' token

It doesn't allow me to take the address of the templated function. The
strange thing is that I can do the same from the main.cxx file, that
is:

// main.cxx

std::map<size_t , double (*)(size_t)loca tion;

location[1] = &loc<1>;
location[2] = &loc<2>;

cout<<"what the -"<<location[2](1)<<endl;

works fine! Is this a problem with my compiler or there is something
wrong with the syntax? I'm using gcc version 4.1.2. I know, I know...
I could just use regular functions and call them loc1, loc2 and so on
and forget about the template (this will definitely work), but hey,
I'm learning day by day and I just cannot give up that easily, right?

a²- Masquer le texte des messages précédents -

- Afficher le texte des messages précédents -

Hi,
I get the following error message. Why? What's wrong with me? Thanks.

error C2039:'map' is not a member of 'std'
----------------
// .h file
#include <iostream>

template <int vdouble loc(size_t); // forward declarations of
function specializations (defined in .cxx file)
template <double loc<1>(size_t);
template <double loc<2>(size_t); // and so on
------------
#include <iostream>
#include "SomeClass. h"
using std::cout;
using std::endl;

int main()
{
std::map<size_t , double (*)(size_t)loca tion;

location[1] = &loc<1>;
location[2] = &loc<2>;
cout<<"using loc<1>: "<<loc<1>(1)<<e ndl;

return 0;

}

You forgot to put 'using std::map;' or just put 'using namespace std;'
and don't forget to implement the actual loc<vfunctions in the cpp
file.

a²

[Daniel T.]

aaragon <al************ **@gmail.comwro te:

The memory in your approach is the same (the executable
will have the same size) but the run time will be much less if I only
initialize what I need.

"More computing sins are committed in the name of efficiency (without
necessarily achieving it) than for any other single reason - including
blind stupidity." - W.A. Wulf

How much less is "much less"?