How to test value of template parameter?

[David Sanders]

Hi,

I have a class with an integer template parameter, taking values 1, 2
or 3, and a function 'calc' in that class which performs
calculations. Some calculations need only be performed if the
template parameter is 2 or 3; for efficiency, I do not wish to perform
the calculations if the template parameter is 1.

I currently do this as follows:

template<int d>
class myclass {

myclass() {
}

void calc() {

// calculation for d==1 goes here -- performed also if d==2 or
d==3

if (d==2) ...
if (d==3) ...
}
};

My question is, how can I replace these tests with a compile-time test
of the value of the template parameter to include only the relevant
code? I have tried #if, but this does not see the value of the
template parameter.

As far as I understand, one solution would be to put the d==2 and d==3
cases in a separate function and use template specialization? But
this seems to be overkill in this simple case.

Thanks and best wishes,
David.

[alan]

On Nov 18, 1:04 pm, David Sanders <dpsand...@gmai l.comwrote:

Hi,

I have a class with an integer template parameter, taking values 1, 2
or 3, and a function 'calc' in that class which performs
calculations. Some calculations need only be performed if the
template parameter is 2 or 3; for efficiency, I do not wish to perform
the calculations if the template parameter is 1.

I currently do this as follows:

template<int d>
class myclass {

myclass() {
}

void calc() {

// calculation for d==1 goes here -- performed also if d==2 or
d==3

if (d==2) ...
if (d==3) ...
}

};

My question is, how can I replace these tests with a compile-time test
of the value of the template parameter to include only the relevant
code? I have tried #if, but this does not see the value of the
template parameter.

If compiler optimizations are turned on, the test will generally be
done at compile-time.

>
As far as I understand, one solution would be to put the d==2 and d==3
cases in a separate function and use template specialization? But
this seems to be overkill in this simple case.

It can be done that way, too.

Sincerely,
AmkG

[Barry]

David Sanders wrote:

Hi,

I have a class with an integer template parameter, taking values 1, 2
or 3, and a function 'calc' in that class which performs
calculations. Some calculations need only be performed if the
template parameter is 2 or 3; for efficiency, I do not wish to perform
the calculations if the template parameter is 1.

I currently do this as follows:

template<int d>
class myclass {

myclass() {
}

void calc() {

// calculation for d==1 goes here -- performed also if d==2 or
d==3

if (d==2) ...
if (d==3) ...
}
};

My question is, how can I replace these tests with a compile-time test
of the value of the template parameter to include only the relevant
code?

AFAIK, there is not.

I have tried #if, but this does not see the value of the

template parameter.

As far as I understand, one solution would be to put the d==2 and d==3
cases in a separate function and use template specialization? But
this seems to be overkill in this simple case.

I think a template parameter of class template is used to generate
generic data member types and generic member functions.

In your case, the "d" template parameter is only used in "calc" for a
if-else switch.

Ignoring the "overkillin g" thing, I would like to suggest you have
template member function, which is more reasonable, and use what you
already mentioned -- "function template specialization" . If this is
overkilling, I think it's already overkilling if you use template here.

<code>
class myClass {
public:
template <int dvoid calc();
};

// MUST be specialized in the "myClass"s enclosing scope,
// MSVC has a bug here.
template <>
void myClass::calc<1 >() {
}

template <>
void myClass::calc<2 >() {
}

int main() {
myClass c;
c.calc<1>();
c.calc<2>();
}
</code>

[David Sanders]

On Nov 18, 3:27 am, alan <almkg...@gmail .comwrote:

On Nov 18, 1:04 pm, DavidSanders<dp sand...@gmail.c omwrote:

Hi,

I have a class with an integer template parameter, taking values 1, 2
or 3, and a function 'calc' in that class which performs
calculations. Some calculations need only be performed if the
template parameter is 2 or 3; for efficiency, I do not wish to perform
the calculations if the template parameter is 1.

I currently do this as follows:

template<int d>
class myclass {

myclass() {
}

void calc() {

// calculation for d==1 goes here -- performed also if d==2 or
d==3

if (d==2) ...
if (d==3) ...
}

};

My question is, how can I replace these tests with a compile-time test
of the value of the template parameter to include only the relevant
code? I have tried #if, but this does not see the value of the
template parameter.

If compiler optimizations are turned on, the test will generally be
done at compile-time.

Ah, I didn't realise that -- very good news, thanks!

Best wishes,
David.

[David Sanders]

On Nov 18, 5:29 am, Barry <dhb2...@gmail. comwrote:

David Sanders wrote:

Hi,

I have a class with an integer template parameter, taking values 1, 2
or 3, and a function 'calc' in that class which performs
calculations. Some calculations need only be performed if the
template parameter is 2 or 3; for efficiency, I do not wish to perform
the calculations if the template parameter is 1.

I currently do this as follows:

template<int d>
class myclass {

myclass() {
}

void calc() {

// calculation for d==1 goes here -- performed also if d==2 or
d==3

if (d==2) ...
if (d==3) ...
}
};

My question is, how can I replace these tests with a compile-time test
of the value of the template parameter to include only the relevant
code?

AFAIK, there is not.

I have tried #if, but this does not see the value of the

template parameter.

As far as I understand, one solution would be to put the d==2 and d==3
cases in a separate function and use template specialization? But
this seems to be overkill in this simple case.

I think a template parameter of class template is used to generate
generic data member types and generic member functions.

In your case, the "d" template parameter is only used in "calc" for a
if-else switch.

Ignoring the "overkillin g" thing, I would like to suggest you have
template member function, which is more reasonable, and use what you
already mentioned -- "function template specialization" . If this is
overkilling, I think it's already overkilling if you use template here.

OK, I guess template specialization really is the right thing to use
after all.
The reason I use a template is, as suggested in my original question,
that code efficiency is critical -- these functions
are called many times, so any way I can eliminate unnecessary code is
good.

>
<code>
class myClass {
public:
template <int dvoid calc();

};

// MUST be specialized in the "myClass"s enclosing scope,
// MSVC has a bug here.
template <>
void myClass::calc<1 >() {

}

template <>
void myClass::calc<2 >() {

}

int main() {
myClass c;
c.calc<1>();
c.calc<2>();}

</code>

Thanks and best wishes,
David.