It can only be done for aggregates (arrays and certain classes. Contrary to popular belief, this works for many nonpods too). Writing a constructor that takes them is not possible.
Since you tagged it as "C++0x", then this is possible though. The magic words is "initializer-list constructor". This goes like
Phenotype(std::initializer_list<uint8> c) { assert(c.size() <= std::size(m_array)); std::copy(c.begin(), c.end(), m_array); } // used like Phenotype p1{1, 2, 3}; Phenotype p2({1, 3, 2}); // works too Phenotype p3(1, 2, 3); // doesn't work
However, such initialization will default construct the array and then use the assignment operator. If you aim for speed and safety (you get compile time errors for too many initializers!), you can also use an ordinary constructor with a variadic template.
This can be more generic than needed though (often an initializer_list completely suffices, especially for plain integers). It benefits from perfect forwarding, so that an rvalue argument can be move constructed into an array element
template<typename ...T> Phenotype(T&&...t):m_array{ std::forward<T>(t)... } { } // used like Phenotype p1{1, 2, 3}; Phenotype p2(1, 2, 3); // works too Phenotype p3({1, 2, 3}); // doesn't work
It's a hard choice!
Edit Correction, the last one works too, as we didn't make the constructor explicit, so it can use the copy constructor of Phenotype, constructing a temporary Phenotype object and copy it over to p3. But that's not what we really would want the calls to be :)
