max value of instantiated template function

[npackard]

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:

#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!

[npackard]

I need to know MAXV at compile time!

[anon]

Might not be possible.

And what about:

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

[npackard]

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

[Elysia]

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.

[cpjust]

Simple:

#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.

[Elysia]

Unfortunately, that solution does not satisfy the requirement:

I need to know MAXV at compile time!

[anon]

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.

[cpjust]

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

[npackard]

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:

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:

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

[anon]

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.

[npackard]

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