max value of instantiated template function

Hi,

I'm wondering if anyone has any tricks to determine the maximum instantiated value for a template function. For exampe, how would one modify the following code without changing main, to make MAXV a valid number:

Code:

---

#include <stdio.h>
template<int V>
void test(){
    printf("V: %d\n",V);
}

int main(){
    test<2>();
    test<6>();
    test<2>();
    test<3>();
   
    printf("maxV: %d\n",MAXV);
    return 0;
}

---

Thanks for the help!

I need to know MAXV at compile time!

Might not be possible.

And what about:

Code:

---

int main(){
    printf("maxV: %d\n",MAXV);
    test<2>();
    test<6>();
    test<2>();
    test<3>();
 
    return 0;
}

---

Yes, ideally that would work as well. I was hoping some template or pre-processor magic could pull it off.

The only way it *might* be possible that I can think of is a recursive solution that takes in all V values at once and finds the result and returning it.

Simple:

Code:

---

#include <algorithm>
#include <stdio.h>

int MAXV = 0;

template<int V>
void test(){
    MAXV = std::max( MAXV, V );
    printf( "V: %d\n", V );
}

int main(){
    test<2>();
    test<6>();
    test<2>();
    test<3>();
   
    printf( "maxV: %d\n", MAXV );
    return 0;
}

---

Although, I don't think this will work at compile time, just run time.

Unfortunately, that solution does not satisfy the requirement:

Quote:

---

Originally Posted by npackard

I need to know MAXV at compile time!

---

I think that requirement is impossible to satisfy. Basically you'd have to create a compile time constant from code that the compiler hasn't seen yet. (Not that is particularly easy to gather compile-time data from instantiation of function templates.)

It would be interesting to know, why OP needs something like that.

Yeah, I'm wondering why you'd need to know that at compile time?

Basically I am a student and have implemented an N-Dimensional Image Class with various image processing routines implemented in ND that I use for medical image processing. I want to implement a generic struct that can hold information about any instantiation of my image class. This struct resides in shared memory to provide information to a separate process that runs a GUI to view the ND data.

For example, the struct looks something like:

Code:

---

struct ViewInfo{
    int nDIM;
    char dataname[sizeof(void*)+1]; //stores an name to access raw data from shared memory
    int datatype; //stores info about scalar type
    int ndim; //number of dimensions
    int ncolors; //number of colors
    int dim[MAXN]; //coordinates of the ND pixel
    float size[MAXN]; //dimensions (in mm) of the ND pixel
};

---

My image class takes in as template parameters the scalar type (i.e. float, int, short, etc) and the dimensionality (i.e. N=1,2,3, or 5000 for example). The advantage to knowing the dimensionality at compile time is that it allows for optimizations of my ND image processing routines. The class looks like:

Code:

---

template<class VoxelType,int N>
class Image {
public:
//...
};

---

I want to create a generic structure that holds information about each instantiation of the image class and resides in shared memory. I can't use dynamic allocation because it gets kind of messy dynamically allocating in shared memory. I could just "#define MAXN 100" for example, but I would rather not limit the max value of N and would rather determine MAXN at compile time depending on the program that is using the library.

I realize that my request is a bit demanding, but if I could figure this out it would make for a much more elegant solution that I could otherwise come up with.

Thanks

Instead of a define you can use a constant, and each instantiation of anything can assert at compile-time that it's N size is less-or-equal to that.

That's a good suggestion Anon, thanks for a workable solution. Maybe my original request is impossible.