Your question is a little bit tricky to understand without an example. My understanding of it is that you want to specialize the constructor of a class template and construct it's member differently for different template arguments. If this isn't correct, let me know and I will adjust my answer.
Again without an example it's hard to know what you do and do not understand. But generally this is done the same way as you would specialize other methods. Declare all the specializations in your headers and implement them in your implementation file (unless they are partial specializations!). Remember to use template<> when specializing. Here is an example :
struct t_param_for_int {};
struct t_param_for_double {};
// t_member's constructor is very different depending on T
template<class T> struct t_member {};
template<> struct t_member<int> {
explicit t_member(const t_param_for_int value) {};
};
template<> struct t_member<double> {
explicit t_member(const t_param_for_double value) {};
};
// Foo has a t_member and a constructor
template<class T>
struct foo
{
foo();
t_member<T> member;
};
// Declare specialization
template<> foo<int>::foo();
template<> foo<double>::foo();
// Specialization implementations (in a .cpp)
template<> foo<int>::foo() : member(t_param_for_int{})
{ }
// Specialization implementations (in a .cpp)
template<> foo<double>::foo() : member(t_param_for_double{})
{ }
int main()
{
foo<int> int_foo;
foo<double> dbl_foo;
return 0;
}
Edit: In response to the edit to the question.
You cannot specialize a constructor in this case. The best solution is likely going to be to use a helper structs to do the actual initialization. You mentioned you want to initialize your containers with some number of 0 or default constructed elements T. However you didn't specify how large your containers should be. I've constructed an example to illustrate the solution of using helper structs using bogus container sizes.
#include <array>
#include <iostream>
#include <type_traits>
#include <string>
#include <utility>
#include <vector>
template<typename T, typename C>
struct helper_init;
template<typename T>
struct helper_init<T, std::vector<T>> {
static std::vector<T> init() {
return std::vector<T>(3, T{}); // init your vector with 3 elements
}
};
template<typename T>
struct helper_init<T, std::array<T, 2>> {
static std::array<T, 2> init() {
return {}; // init your array with 2 elements
}
};
template <typename T, typename C>
struct foo {
T m;
C container;
using value_type = typename C::value_type;
template <typename... Args>
foo(Args&&... args)
: m(std::forward<Args>(args)...)
, container(helper_init<T, C>::init())
{}
};
int main()
{
foo<int, std::vector<int>> vec_foo(5);
foo<std::string, std::array<std::string, 2>> str_foo("hello");
// Output to illustrate
// The size of the containers are 3 and 2 (see container initialization)
std::cout << vec_foo.container.size() << ' '
<< str_foo.container.size() << std::endl;
// The m members contain the assigned values
std::cout << vec_foo.m << " \'" << str_foo.m << '\'' << std::endl;
// The containers are zero or default initialized
std::cout << vec_foo.container.front() << " \'" <<
str_foo.container.front() << '\'' << std::endl;
return 0;
}
For the second part of your question, initializing to 0 to arithmetic types and default constructing for class types, the language already has a feature for this.
std::array specifically says this about it's construction.
initialized the array following the rules of aggregate initialization
Then aggregate initialization says this.
If the number of initializer clauses is less than the number of members or initializer list is completely empty, the remaining members are value-initialized.
Finally value initialization says this.
1) if T is a class type with at least one user-provided constructor of any kind, the default constructor is called;
4) otherwise, the object is zero-initialized.
This allow us to do this std::array<T, 10> my_array{}; and have ten zeroed or default constructed Ts. We can also do std::vector<T> my_vector(10, T{}); to get the same results (T{} is value constructed`).
Edit 2: Here is another solution that more adheres to the question's requirements using a [delegating constructor] and tag dispatching.
#include <array>
#include <string>
#include <vector>
// Tags for supported containers
struct t_tag_array {};
struct t_tag_vector {};
// Tag dispatching
template<class T, size_t S>
struct t_container_tag {};
template<class T, size_t S>
struct t_container_tag<std::vector<T>, S> {
using type = t_tag_vector;
};
template<class T, size_t S>
struct t_container_tag<std::array<T, S>, S> {
using type = t_tag_array;
};
// Helper to fetch the size of an std::array
template<typename>
struct array_size;
template<typename T, size_t S>
struct array_size<std::array<T, S>> {
static const auto value = S;
};
template <typename C, size_t S = array_size<C>::value>
struct foo
{
using value_type = typename C::value_type;
// Constructor
template<typename... Args>
foo(Args&&... args) : foo(typename t_container_tag<C, S>::type{}, std::forward<Args>(args)...) {}
// Specialized constructor for vectors
template<typename... Args>
foo(t_tag_vector &&, Args&&... args) : m(std::forward<Args>(args)...), container(S, value_type{}) {}
// Specialized constructor for arrays
template<typename... Args>
foo(t_tag_array &&, Args&&... args) : m(std::forward<Args>(args)...), container{} {}
value_type m;
C container;
};
