A promble about template!

[zhangxiaobin]

I defined a tempate class like this,it works fine,but I am a bit confusing that why the constructor's parameters must be const? Can someone help me explain that.Thanks!

sourcecode:

template<typename T_1 = int , typename T_2 = double >
class CTemplateClass{
private :
T_1 param_1;
T_2 param_2;
public :
CTemplateClass( const T_1 & param1 , const T_2 & param2){
param_1 = param1;
param_2 = param2;
cout<<"This is the CTemlpateClass constructor."<<endl;
}
virtual ~CTemplateClass(){
cout<<"This is the CtemplateClass destructor."<<endl;
}

virtual const T_1 & get_param_1() const {
return param_1;
}

virtual const T_2 & get_param_2() const {
return param_2;
}

virtual void somtother(){
cout<<"SomeOther function..."<<endl;
}
};

[blackcoder41]

To make sure that the constructor won't change(mess) the arguments :)

[jsmith]

Well, aside from that reason, since the type of these parameters is templated, you don't know how
expensive it is to copy the actual parameter onto the stack. For simple ints, indeed the const reference
will be very slightly slower than if the formal parameter were just a value. For things like std::string
or an STL container, it could take a long time to copy the entire container onto the stack. When
writing a generic class like this, it is best to assume worst case and pass by const reference (const
to document to your user the fact that the constructor will not be modifying the argument).

Setting that aside. Creating generic templates is not easy. Your template makes a couple of
additional requirements on T_1 and T_2 that it does not need to make. For example, the
implementation of your constructor mandates that T_1 and T_2 both be default constructible
and assignable. Now, assignable may not be too bad, considering that at best they will have
to be copyable, and objects that are copyable are usually (but not always) assignable. But
the default constructible is not only annoying, but could incur a runtime penalty if default
construction is expensive.

A better way to write the constructor is to use initializer lists:

CTemplateClass( const T_1& p1, const T_2& p2 ) :
    param_1( p1 ), param_2( p2 )
{}

In calling my version of the constructor, T_1's copy constructor will be invoked exactly
once, and T_2's copy constructor will be invoked exactly once.

In calling your version of the constructor, T_1's default constructor will be invoked once,
then T_2's default constructor once, then T_1's assignment operator once, then T_2's
assignment operator once.

[zhangxiaobin]

Thanks a lot! jsmith and blockcoder41 I think I hava got the answer,I am very appreciate for you help!