is there a way to Bind templates parameter lists?

[ManicQin]

I have two templated classes
for example let's say:

template <typename _T , class _Trait>
class modifier
{
public:
_T modify()
{
return _Trait::change(m_data);
}

_T m_data;
};

template <typename _T>
class TraitSample
{
static _T change(_T value) { return value + 1; }
};

when I instantiate a modifier class I need to supply the type of the
typename
in the modifier and in the trait class:
modifier<int ,TraitSample<int sample;
is there a way to "bind" the two parameters?
(and in the case of more parameters a way to pair them all)

Thanks.

[Rolf Magnus]

ManicQin wrote:

I have two templated classes
for example let's say:

template <typename _T , class _Trait>

Names starting with an underscore followed by an uppercase letter are
reserved for the compiler. You should not use them for your own purposes.

class modifier
{
public:
_T modify()
{
return _Trait::change(m_data);
}

_T m_data;
};

template <typename _T>
class TraitSample
{
static _T change(_T value) { return value + 1; }
};

when I instantiate a modifier class I need to supply the type of the
typename
in the modifier and in the trait class:
modifier<int ,TraitSample<int sample;
is there a way to "bind" the two parameters?
(and in the case of more parameters a way to pair them all)

You can specify default types for template parameters, like:

template <typename _T , class _Trait = TraitSample<_T
class modifier
....

[ManicQin]

On Aug 3, 11:16*pm, Rolf Magnus <[e-mail]:

>
You can specify default types for template parameters, like:

template <typename _T , class _Trait = TraitSample<_T
class modifier
...

Yes but if I want to change the TraitSample in any other class
that wont be very helpful... I'll be in the same situation.

[ManicQin]

On Aug 4, 8:34*am, ManicQin <[e-mail]:

Yes but if I want to change the TraitSample in any other class
that wont be very helpful... I'll be in the same situation.

I meant to any other class.

>Names starting with an underscore followed by an uppercase letter are
reserved for the compiler. You should not use them for your own purposes.

I'm used to see STL headers using the same convention so I adopted it.
What is the preferred convention?

[Francesco]

On 4 Ago, 08:46, ManicQin <[e-mail]:

On Aug 4, 8:34*am, ManicQin <[e-mail]:

Yes but if I want to change the TraitSample in any other class
that wont be very helpful... I'll be in the same situation.

I meant to any other class.

Names starting with an underscore followed by an uppercase letter are
reserved for the compiler. You should not use them for your own purposes..

I'm used to see STL headers using the same convention so I adopted it.
What is the preferred convention?

Hi,
try something like the following.
Bye,
Francesco
template <typename _T>
class TraitSample
{
static _T change(_T value) { return value + 1; }
};

template <typename _T>
class TraitSample2
{
static _T change(_T value) { return value + 1; }
};
template <typename _T , template< typename class _Trait =
TraitSample >
class modifier
{
public:
_T modify()
{
return _Trait< _T >::change(m_data);
}
_T m_data;

};

int main()
{
modifier< int object;
modifier< double, TraitSample2 > object2;
}

[ManicQin]

On Aug 4, 10:28*am, "Alf P. Steinbach" <[e-mail]:

This seems like trolling.

Sorry for starting a trolling but to who\what were you referring?

Fancesco Wrote:

>template <typename _T>
class TraitSample
{
static _T change(_T value) { return value + 1; }

};

template <typename _T>
class TraitSample2
{
static _T change(_T value) { return value + 1; }

};

template <typename _T , template< typename class _Trait =
TraitSample >
class modifier
{
public:
_T modify()
{
return _Trait< _T >::change(m_data);
}

_T m_data;

};

int main()
{
modifier< int object;
modifier< double, TraitSample2 object2;

Thank you Francesco you were right that was the solution I was looking
for.
The problem is that when combining your advice with inheritance of
modifier
class and longer template parameter lists (slowly specializing the
modifier class)
it becomes hard to implement it (at least for a novice programmer like
me).

Thank you!

[James Kanze]

On Aug 4, 8:46 am, ManicQin <[e-mail]:

On Aug 4, 8:34 am, ManicQin <[e-mail]:

Names starting with an underscore followed by an uppercase
letter are reserved for the compiler. You should not use them
for your own purposes.

I'm used to see STL headers using the same convention so I
adopted it.

The STL is part of the implementation, so it cannot use names
that you are allowed to use. That's why such names are
reserved.

What is the preferred convention?

Just about anything else:-). For container templates, a lot of
people use simply T (although I'm not sure that that's a good
idea).

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]