HI

[Ganesh]

Can template declarations take string types as template parameters,
just like int types? If not, why it has been designed like that?

Ganesh

[Michael Olea]

Ganesh wrote:

Can template declarations take string types as template parameters,
just like int types? ...
Nope. No floating point types either.
...If not, why it has been designed like that?

Well, consider and example from C++ Templates: The Complete Guide

template <char const* msg>
class Foo { public: void print(); };

int main()
{
Foo<"Hiya!">().print();
}

Two instances of Foo are the same type if and only if they have the
same arguments. Here the argument is a pointer value - in other words
an address. Two identical string literals need not have the same address,
so Foo<"X"> and in some other source file say Foo<"X"> could be two
distinct and hence incompatible types.

Floating point non-type template arguments are less problematic.

[Larry I Smith]

Ganesh wrote:

Can template declarations take string types as template parameters,
just like int types? If not, why it has been designed like that?

Ganesh

They can be native types (int, char, long, double, etc) and
any class type (including other template classes), as well as
pointers to all of these. So yes, std::string is fine.

Larry

[Larry I Smith]

Larry I Smith wrote:

Ganesh wrote:

Can template declarations take string types as template parameters,
just like int types? If not, why it has been designed like that?

Ganesh

They can be native types (int, char, long, double, etc) and
any class type (including other template classes), as well as
pointers to all of these. So yes, std::string is fine.

Larry

Opps, forget the pointers.

Larry

[Larry I Smith]

Michael Olea wrote:

Ganesh wrote:

Can template declarations take string types as template parameters,
just like int types? ...

Nope. No floating point types either.

...If not, why it has been designed like that?

Well, consider and example from C++ Templates: The Complete Guide

template <char const* msg>
class Foo { public: void print(); };

int main()
{
Foo<"Hiya!">().print();
}

Two instances of Foo are the same type if and only if they have the
same arguments. Here the argument is a pointer value - in other words
an address. Two identical string literals need not have the same address,
so Foo<"X"> and in some other source file say Foo<"X"> could be two
distinct and hence incompatible types.

Floating point non-type template arguments are less problematic.

These templates all work just fine, both pointer and non-pointer
variants. So pointers are valid.

std::vector<int> iv;
std::vector<int *> ipv;
std::vector<char> cv;
std::vector<char *> cpv;
std::vector<double> dv;
std::vector<double *> dpv;

Larry

[Michael Olea]

Larry I Smith wrote:

Michael Olea wrote:

Ganesh wrote:

Can template declarations take string types as template parameters,
just like int types? ...

Nope. No floating point types either.

...If not, why it has been designed like that?

Well, consider and example from C++ Templates: The Complete Guide

template <char const* msg>
class Foo { public: void print(); };

int main()
{
Foo<"Hiya!">().print();
}

Two instances of Foo are the same type if and only if they have the
same arguments. Here the argument is a pointer value - in other words
an address. Two identical string literals need not have the same address,
so Foo<"X"> and in some other source file say Foo<"X"> could be two
distinct and hence incompatible types.

Floating point non-type template arguments are less problematic.

These templates all work just fine, both pointer and non-pointer
variants. So pointers are valid.

std::vector<int> iv;
std::vector<int *> ipv;
std::vector<char> cv;
std::vector<char *> cpv;
std::vector<double> dv;
std::vector<double *> dpv;

Larry

I believe the OP was talking about *non-type* template parameters. For
example:

std::bitset<42> aSet;

where bitset is something like:

template<size_t N> class bitset { ... };

What is not legal (though some compilers have extensions allowing it) is

template <float x> class Foo { ... }; Foo<42.0> aFoo; or
template <const char* s> class Bar { ... }; Bar<"Hello, World!"> aBar;

Your examples above are all type parameters - not relevant to the question
of what non-type parameters are legal.

[Larry I Smith]

Michael Olea wrote:

Larry I Smith wrote:

Michael Olea wrote:

Ganesh wrote:

Can template declarations take string types as template parameters,
just like int types? ...
Nope. No floating point types either.

[snip]
These templates all work just fine, both pointer and non-pointer
variants. So pointers are valid.

std::vector<int> iv;
std::vector<int *> ipv;
std::vector<char> cv;
std::vector<char *> cpv;
std::vector<double> dv;
std::vector<double *> dpv;

Larry

I believe the OP was talking about *non-type* template parameters. For
example:

[snip]

I didn't get that at all from the original question:

"Can template declarations take string types as template
parameters, just like int types?"

std::string is a valid template parameter, so my answer
to the quoted question would be 'yes'.

Oh well...

Larry

[Michael Olea]

Larry I Smith wrote:

[...]

I believe the OP was talking about *non-type* template parameters. For
example:

[snip]

I didn't get that at all from the original question:

"Can template declarations take string types as template
parameters, just like int types?"

Yeah - we were answering different questions. The question does contain the
word "types" so maybe you are right about what was being asked. Either way,
the question (whichever version it was) has been answered ;-)

[Peter Julian]

"Michael Olea" <ol***@sbcglobal.net> wrote in message
news:HL******************@newssvr14.news.prodigy.c om...

Ganesh wrote:

Can template declarations take string types as template parameters,
just like int types? ...
Nope. No floating point types either.

How do you figure that? Any type, primitive or not, can be substituted in a
template. One does not arm a template with a literal or instance of a type.

...If not, why it has been designed like that?

Well, consider and example from C++ Templates: The Complete Guide

template <char const* msg>
class Foo { public: void print(); };

int main()
{
Foo<"Hiya!">().print();
}

#include <iostream>
#include <string>

template< class S >
class Foo
{
S m_s;
public:
Foo(S s) : m_s(s) { }
~Foo() { }
friend std::ostream& operator<<(std::ostream& os, Foo< S >& r_foo);
};

template< class S >
std::ostream& operator<<(std::ostream& os, Foo< S >& r_foo)
{
std::cout << "Foo's member is " << r_foo.m_s << "\n";
return os;
}

int main()
{
Foo<std::string> s_foo("a short string");
std::cout << s_foo;

Foo<double> d_foo(99.9);
std::cout << d_foo;

return 0;
}

/*
Foo's member is a short string
Foo's member is 99.9
*/

[Michael Olea]

Peter Julian wrote:

"Michael Olea" <ol***@sbcglobal.net> wrote in message
news:HL******************@newssvr14.news.prodigy.c om...

Ganesh wrote:

> Can template declarations take string types as template parameters,
> just like int types? ...
Nope. No floating point types either.

How do you figure that?

Simple - I took the question to be about non-type template parameters.
Any type, primitive or not, can be substituted in
a template.
Right, but for non-type template parameters there are restrictions - no
floating point types, for example.
One does not arm a template with a literal or instance of a
type.

You can find lots of examples of templates designed to be instantiated with
values (compile time constant experssions) in stl, boost, books by
Alexandrescu, Vandevoorde and Josuttis, and (speaking of "arm") Ellis and
Stroustrup.

Here's one:

template<size_t _Nb>
class bitset : private _Base_bitset<_GLIBCPP_BITSET_WORDS(_Nb)> {...}

And here's one:

template<bool C, typename T1, typename T2> class IfElse;
template<typename T1, typename T2> class IfElse<true, T1, T2>
{ public: typedef T1 Type; };
template<typename T1, typename T2> class IfElse<false, T1, T2>
{ public: typedef T2 Type; };

And here's one:

template <size_t N, typename T, T val>
class ArrayInitConst
{
public:
static void Apply(T *p)
{
*p++ = val;
ArrayInitConst<N-1,T,val>::Apply(p);
}
};

template <typename T, T val>
class ArrayInitConst<1, T, val>
{
public:
static void Apply(T *p) { *p = val; }
};

[Ganesh]

Thanks.

[Ganesh]

Yes, I was asking about non-type template parameters.