allocator traits?

[Alexander Stippler]

Hi,

I want to use a different Konstruktor to initialize an array depending on
the type of objects stored. I guess it has something to do with accolator
traits, but I'm not quite sure how to handle. This is the situation:

template <typename T>
class B {
public:
B(int i) {
std::fill(t_, i, T() ) (!)
}
private:
T t_[10];
};

In the call of std::fill I want to have T() for all types except a few, for
which I would like to call T(1,1). How to manage this?

regards,
alex

[llewelly]

Alexander Stippler <st**@mathematik.uni-ulm.de> writes:

Hi,

I want to use a different Konstruktor to initialize an array depending on
the type of objects stored. I guess it has something to do with accolator
traits, but I'm not quite sure how to handle. This is the situation:

template <typename T>
class B {
public:
B(int i) {
std::fill(t_, i, T() ) (!)
}
private:
T t_[10];
};

In the call of std::fill I want to have T() for all types except a few, for
which I would like to call T(1,1). How to manage this?

Specialization.

#include<algorithm>

template <typename T>
class B {
public:
B(int i) {
std::fill(t_, t_ + i, T() );
}
private:
T t_[10];
};

struct special_type
{
special_type():x(0),y(0){}
special_type(int x,int y):x(x),y(y){}
int x,y;
};

template<>
B<special_type>::B(int i){std::fill(t_, t_ + i, special_type(1,1));}

int main()
{
B<special_type> b(1);
}

[Alexander Stippler]

llewelly wrote:

Alexander Stippler <st**@mathematik.uni-ulm.de> writes:

Hi,

I want to use a different Konstruktor to initialize an array depending on
the type of objects stored. I guess it has something to do with accolator
traits, but I'm not quite sure how to handle. This is the situation:

template <typename T>
class B {
public:
B(int i) {
std::fill(t_, i, T() ) (!)
}
private:
T t_[10];
};

In the call of std::fill I want to have T() for all types except a few,
for which I would like to call T(1,1). How to manage this?

Specialization.

#include<algorithm>

template <typename T>
class B {
public:
B(int i) {
std::fill(t_, t_ + i, T() );
}
private:
T t_[10];
};

struct special_type
{
special_type():x(0),y(0){}
special_type(int x,int y):x(x),y(y){}
int x,y;
};

template<>
B<special_type>::B(int i){std::fill(t_, t_ + i, special_type(1,1));}

int main()
{
B<special_type> b(1);
}

With respect to my question your solution is prefectly right. Unfortunately
I wasn't precise. I want to have a solution on class level and I would like
to be free in the choice of the constructor call in the initialization.
Thus I would like to have an additional template parameter (with default
value 'default constructor', which would provide the concrete constructor
to be used. I know that such things are possible, but I'm far away from
knowing how to realize it.

Regards,
alex

[tom_usenet]

On Tue, 02 Sep 2003 16:06:19 +0200, Alexander Stippler
<st**@mathematik.uni-ulm.de> wrote:

Hi,

I want to use a different Konstruktor to initialize an array depending on
the type of objects stored. I guess it has something to do with accolator
traits, but I'm not quite sure how to handle. This is the situation:

template <typename T>
class B {
public:
B(int i) {
std::fill(t_, i, T() ) (!)
}
private:
T t_[10];
};

In the call of std::fill I want to have T() for all types except a few, for
which I would like to call T(1,1). How to manage this?
template <class T>
struct default_creation_traits
{
static T default_value()
{
return T();
}
};

template <
typename T,
class CreationTraits = default_creation_traits<T>

class B
{
typedef CreationTraits creation_traits;
public:
B(int i) {
std::fill(t_, i, creation_traits::default_value());
}
private:
T t_[10];
};

template <class T>
struct special_creation_traits
{
static T default_value()
{
return T(1, 1);
}
};

Then, use
typedef B<mytype> mytypeB;
and
typedef B<myothertype, special_creation_traits<myothertype> >
myothertypeB;

or whatever. There are a number of approaches, depending on your exact
requirements, but the above is similar to the char_traits approach
used by basic_string.

Tom

[Alexander Stippler]

tom_usenet wrote:

template <class T>
struct default_creation_traits
{
static T default_value()
{
return T();
}
};

template <
typename T,
class CreationTraits = default_creation_traits<T>

class B
{
typedef CreationTraits creation_traits;
public:
B(int i) {
std::fill(t_, i, creation_traits::default_value());
}
private:
T t_[10];
};

template <class T>
struct special_creation_traits
{
static T default_value()
{
return T(1, 1);
}
};

Then, use
typedef B<mytype> mytypeB;
and
typedef B<myothertype, special_creation_traits<myothertype> >
myothertypeB;

or whatever. There are a number of approaches, depending on your exact
requirements, but the above is similar to the char_traits approach
used by basic_string.

Tom

Thank you very much, Tom. It's exactly what I desired.

regards,
alex