I have a template class like this:
template <unsigned N>
class Pixel {
float color[N];
}
I hope to have a constructor with exact N parameters to initialize the array in the class, like this:
Pixel<N> (float x_1, float x_2, ..., float x_N) {
color[0] = x_1;
color[1] = x_2;
...
}
Obviously I can't implement the constructor by hand for each N. So how can I achieve this goal by template metaprogramming or any other techniques?
The other answers are good and practical, but the question is interesting, and the technique behind doing something like that can form a good basis for similar, but more complicated and/or practical problems and solutions. Here's something that counts the constructor arguments the way you describe:
template <unsigned int N>
class Pixel {
public:
template<typename... Floats> //can't use float... anyway
Pixel(Floats&&... floats) : color{std::forward<Floats>(floats)...} {
static_assert(sizeof...(Floats) == N, "You must provide N arguments.");
}
private:
float color[N];
};
int main() {
Pixel<3> p(3.4f, 5.6f, 8.f);
Pixel<3> p2(1.2f); //static_assert fired
}
I would make use of std::array like so:
#include <array>
#include <iostream>
template<unsigned int N>
class Pixel
{
public:
Pixel(std::array<float, N> values)
{
for(size_t i=0; i<N; i++)
{
colors[i] = values[i];
}
}
private:
float colors[N];
};
int main(int argc, char* argv[])
{
std::array<float, 5> array = { 0.0f, 1.1f, 2.2f, 3.3f, 4.4f };
Pixel<5> p(array);
return 0;
}
I used float colors[N]; as the member variable because that's what it seemed like you had, but if it were up to me I'd just store the array itself. If you don't have access to a c++11 compiler there may be a way to get a similar result using boost::tuple (chris informs me that std::tuple is also c++11, oops).
A lot here depends on where you're starting from (C++03 vs. C++11) and where you really want to go (passing just numbers, or if passing something like an std::array works for you).
If you have C++11 and you just want to pass the numbers, it's probably easiest to do something like:
#include <vector>
#include <iostream>
#include <initializer_list>
class pixel {
std::vector<double> color;
public:
pixel(std::initializer_list<double> && l) : color(l) {}
~pixel() {
// show the data we received:
for (double const &f : color)
std::cout << f << "\t";
}
};
int main() {
pixel{1.9, 2.8, 3.7, 4.6, 5.5};
}
Note that an std::initializer_list doesn't support narrowing conversions, so if you want to store the numbers as float instead of double, you'll need to actually pass floats:
pixel{1.9f, 2.8f, 3.7f, 4.6f, 5.5f};
Unlike @Chris's solution, however, this does not attempt to enforce passing a given number of arguments -- it just conforms to storing whatever number you pass. In return for that, it's a bit easier to use. You don't need to specify the size -- it figures that out from the number of items you pass.
If you like that general idea, but insist on an array and C++03 (why?) you can do something like this:
#include <vector>
#include <iostream>
#include <algorithm>
template<class T, size_t N>
class pixel {
T color[N];
public:
pixel(T(&matrix)[N]) {
std::copy_n(matrix, N, color);
}
};
template <class T, size_t N>
pixel<T, N> make_pixel(T(&matrix)[N]) {
return pixel<T, N>(matrix);
}
int main() {
float a [] = { 1.1, 2.2, 3.3, 4.4, 5.5 };
pixel<float, 5> p = make_pixel(a);
return 0;
}
In this case, I've passed float as a template parameter, but if you're really sure it'll always be float, you can just pass the size, and use float instead of T.
