Can one parameter in a C++11 template depend on another?

Question

My class SimRank has two floating-point constant parameters, C and D. I would like them to be static constexprs, not const instance members. But I also want to let the user choose which kind of floating-point to use, float for size or double for precision.

The obvious way to do it is like this:

template<typename FP, int _K, FP _C, FP _D>
class SimRank {
    static constexpr int K = _K;
    static constexpr FP C = _C;
    static constexpr FP D = _D;
};

template<int _K, float _C, float _D>
class SimRank<float> {};

template<int _K, double _C, double _D>
class SimRank<double> {};

int main() {
    SimRank<5, 0.8, 0> sd; // uses double
    SimRank<10, 0.6f, 0.05f> sf; // uses float
    return 0;
}

But gcc prints many error messages when I try this, so apparently that syntax doesn't exist. I also can't do anything like this:

template<typename FP> template<int _K, FP _C, FP _D> class SimRank {...};

Is there any syntax that lets me specify K, C, D, and the type of C and D at compile time? Right now I've settled for const members:

template<typename FP>
class SimRank {
private:
    const int K;
    const FP C;
    const FP D;
public:
    SimRank(int K, FP C, FP D) : K(K), C(C), D(D) {}
};

class SimRankF : public SimRank<float> {
public:
    SimRankF(int K, float C, float D) : SimRank<float>(K, C, D) {}
};

class SimRankD : public SimRank<double> {
public:
    SimRankD(int K, double C, double D) : SimRank<double>(K, C, D) {}
};

int main() {
    SimRankD sd(5, 0.8, 0.0);
    SimRankF sf(10, 0.6f, 0.05f);
    return 0;
}

(Actually, even if I have to keep the const member solution, I would like a way to define SimRankF and SimRankD without repeating the constructor for each. Leaving it out makes gcc print error: no matching function for call to 'SimRankF::SimRankF(int, float, float)' when I try to instantiate a SimRankF.)

OT: Identifiers that begin with a _ followed by an uppercase letter are reserved for the implementation for any use. [Details](http://stackoverflow.com/questions/228783/what-are-the-rules-about-using-an-underscore-in-a-c-identifier) — Baum mit Augen, Jul 02 '15 at 22:11

score 6 · Accepted Answer · edited May 23 '17 at 12:13

6

There are two problems,

First, template non-type parameters cannot be of type float or double.

Second, the syntax of partial specialization declaration (and its use in main) is wrong.

It has nothing to do with C++11, BTW.

Read an introductory text on C++ templates is the best way to go for you.

edited May 23 '17 at 12:13

Community

1
1

answered Jul 02 '15 at 22:13

Yan Zhou

2,709
2
22
37

score 3 · Answer 2 · answered Jul 02 '15 at 22:23

You cannot use:

template<typename FP, int _K, FP _C, FP _D>
class SimRank {
    static constexpr int K = _K;
    static constexpr FP C = _C;
    static constexpr FP D = _D;
};

when the expected types for FP is float or double since a non-type template parameter cannot be a float or a double.

You can use what you came up with as your solution:

template<typename FP>
class SimRank {
private:
    const int K;
    const FP C;
    const FP D;
public:
    SimRank(int K, FP C, FP D) : K(K), C(C), D(D) {}
};

It's not clear how K is going to be used but you can also use:

template<typename FP, int K>
class SimRank {
private:
    const FP C;
    const FP D;
public:
    SimRank(FP C, FP D) : C(C), D(D) {}
};

and create instances of the class as:

SimRank<double, 5> sd(0.8, 0.0);
SimRank<float, 10> sf(0.8f, 0.0f);

Can one parameter in a C++11 template depend on another?

2 Answers2