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

From:

aaragon <alejandro.aragon@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Sat, 29 Dec 2007 23:42:53 -0800 (PST)

Message-ID:

<3dd0353f-1bda-4c06-af40-c272782fbde5@75g2000hsv.googlegroups.com>

On Dec 29, 7:56 pm, fl <rxjw...@gmail.com> wrote:

On 29 d=E9c, 15:09, aaragon <alejandro.ara...@gmail.com> wrote:

On Dec 29, 10:52 am, "Daniel T." <danie...@earthlink.net> wrote:

aaragon <alejandro.ara...@gmail.com> wrote:

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 extreme=

fast and you are running the program thousands of times per second, th=

you should be embedding this code in a program that makes several pass=

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<MapPolicy>::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)> location;

    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=B2- Masquer le texte des messages pr=E9c=E9dents -

- Afficher le texte des messages pr=E9c=E9dents -

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 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
------------
#include <iostream>
#include "SomeClass.h"
using std::cout;
using std::endl;

int main()
{
    std::map<size_t, double (*)(size_t)> location;

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

        return 0;

}

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

a=B2