template constructor

heya,

im a little confused about an issue with templates..

i understand templates can be used to pass multiple objects (e.g related by inheritance) and one may call template<class T>'s methods etc..

however, if we have templates with member functions, constructors and member variables, where do these come into play?

i.e

Code:

---


template<class T>
int
whatever<T>::size(void) {
        return fileSize;
}

---

is this defining the actual size() variable for all objects passed into the template?

similarly, if we have something like

Code:

---


whatever<T>::whatever(string)

---

when will the template's actual constructor be called?

tia

-twans

is this defining the actual size() variable for all objects passed into the template?

that should read size() method..

actually, they are not existing before its instantiation.

if you write following code
whatever<int> x; //instance the class template

now, you get an object of template class whatever<int>, and now, its constructor is called.


whatever<T>::whatever(string); this code is not to call the contructor, it is illegal and syntax error

so can a template have an actual constructor?

what if we have the following scenario:

string s;
whatever<s> p;

does this create an instance of the template called p of type s?

im finding the concept a little hard to grasp.

thanks for your reply :)

whatever<T>::whatever(string) {//implementation} actually works and compiles fine.

so if one calles

Code:

---

whatever<int> s("hello");

---

do we get an object of type whatever<int> ? and does it has the properties of both a normal class?.

so in the example above, if whatever<class T> had instance varialbes x and y (both public) can we call s.x=0 and s.y=10 and its modifying the actual instance of the 'whatever' class?

thanks again.

-twan

Code:

---

string s;
whatever<s> p;

---

it's incorrect,it should be

Code:

---

whatever<string> p;

---

in < >, it just can be a type parameter,not an variable
so
whatever<T> and whatever<U> have differenet constructor and all the things of their are different though they look like sibling

ahh, i think i understand..

the actual whatever<int> is a differnt object to int itself, correct? so my whatever<string> s; might create an object with methods size(), operator<< etc which are defined in my whatever<class T> template, which differ from those in string itself?

do we get an object of type whatever<int> ? and does it has the properties of both a normal class?.

yes,but i don't know what you meant it has the properties of both a normal class.


whatever<int> x;

you can see it as
whatever_int x;

whatever_int is a new class, compiler replaced the template parameter with int, in this way, it's a normal class actually

great!

thanks for your help

i was confusing template classes for simply adding additional , generic methods, but in fact they are -as you informed me- new classes in themselves.

i appreciate the help.

-twans

you r welcome, heihei~~~

Quote:

---

in < >, it just can be a type parameter,not an variable

---

You're right in saying that cannot be a variable, but incorrect in saying it can only be a type. the parameters inside the < >'s can also be some sort of integral constant.

Code:

---

template <typename type, int size>
class FancyArray
{
    public:
    type  array[size];
};

---

It doesn't have to be an integral constant.

So far I've seen as a template parameter:
A particular class, function pointer, some value, a pointer to an array of class objects

:D
yeah, and can also be address of a 'static' object which has external linkage

Code:

---

template<char *str>
class X{};

namespace
{
    char buffer[]="hello";
}


X<buffer> x;

---

you realize that you just contradicted yourself?

Quote:

---

object which has external linkage

---

Code:

---

namespace
{
    char buffer[]="hello";
}

---

The linkage of an unnamed namespace is.... thats right internal

Quote:

---

The linkage of an unnamed namespace is.... thats right internal

---

some books say it is internal, in fact, it is external, see TC++PL
and you can take a test.

the code i mentioned will be compiled, in other words, everything in the unnamed namespace has external linkage. on the another hand, everything in unnamed namespace is just visible in current translation unit.

Quote:

---

Originally Posted by ISO/IEC 14882:2003(E) Footnote of 7.3.1.1.2

82) Although entities in an unnamed namespace might have external linkage, they are effectively qualified by a name unique to their translation unit and therefore can never be seen from any other translation unit.

---

Quote:

---

Originally Posted by ISO/IEC 14882:2003(E) 2.1

The text of the program is kept in units called source files in this International Standard. A source file together with all the headers (17.4.1.2) and source files included (16.2) via the preprocessing directive #include, less any source lines skipped by any of the conditional inclusion (16.1) preprocessing directives, is called a translation unit. [Note: a C + + program need not all be translated at the same time. ]

---

Gotta love that C++ standard

Lets see here:

Quote:

---

Originally Posted by 14.1.1

template-parameter:
type-parameter
parameter-declaration
type-parameter:
class identifieropt
class identifieropt = type-id
typename identifieropt
typename identifieropt = type-id
template < template-parameter-list > class identifieropt
template < template-parameter-list > class identifieropt = id-expression

---

Quote:

---

Originally Posted by 14.1.3

A type-parameter defines its identifier to be a type-name (if declared with class or typename) or
template-name (if declared with template) in the scope of the template declaration. [Note: because of
the name lookup rules, a template-parameter that could be interpreted as either a non-type templateparameter
or a type-parameter (because its identifier is the name of an already existing class) is taken as a
type-parameter.

---

Quote:

---

Originally Posted by 14.1.4

A non-type template-parameter shall have one of the following (optionally cv-qualified) types:
— integral or enumeration type,
— pointer to object or pointer to function,
— reference to object or reference to function,
— pointer to member.

---

Quote:

---

Originally Posted by 14.1.5-14.1.7

5 [Note: other types are disallowed either explicitly below or implicitly by the rules governing the form of
template-arguments (14.3). ] The top-level cv-qualifiers on the template-parameter are ignored when
determining its type.
6 A non-type non-reference template-parameter is not an lvalue. It shall not be assigned to or in any other
way have its value changed. A non-type non-reference template-parameter cannot have its address taken.
When a non-type non-reference template-parameter is used as an initializer for a reference, a temporary is
always used.

---

Theres more but I really don't feel like quoting the entire 14.1 section

Quote:

---

82) Although entities in an unnamed namespace might have external linkage

---

so

Code:

---

namespace{
    char buffer[256];
}

---

the buffer has external linkage, because no static specified

so
X<buffer> is correct.

Its not really external linkage as no one outside of the translation unit can get to that variable.

Try this:
file1.c

Code:

---

namespace {
  char buffer[256];
};

---

file2.c

Code:

---

extern buffer;
X<buffer>

---

And tell me if that works.

an unnamed namespace is the new way of saying the deprecated static. Anything in an unnamed namespace is only available to that translation unit in which the namespace is declared therefore linkage is internal.

to Thantos:
take a look at this code

Code:

---

//file.cpp
namespace {
  char buffer_external[256];      //external linkage
  static char buffer_internal[256];  //internal linkage
};

template<char* P> class X{};

int main()
{
  X<buffer_external> x;  //it's OK,
  X<buffer_internal> y;    //error, buffer_internal has not external linkage
}

---

back to your code

Code:

---

//file1.c
namespace {
  char buffer[256];
};

//file2.c
extern buffer;
X<buffer> x;

---

now, definition of x is failed, because buffer is in an unnamed namespace and in onther translation unit. but it does not indicate buffer has internal linkage, it still has external linkage, it just says buffer is not available to that translation

refer to

Quote:

---

Although entities in an unnamed namespace might have external linkage, they are effectively qualified by a name unique to their translation unit and therefore can never be seen from any other translation unit.

---

Since you won't listen to me:

Quote:

---

Originally Posted by 3.5.1

2 A name is said to have linkage when it might denote the same object, reference, function, type, template, namespace or value as a name introduced by a declaration in another scope:
— When a name has external linkage, the entity it denotes can be referred to by names from scopes of other translation units or from other scopes of the same translation unit.
— When a name has internal linkage, the entity it denotes can be referred to by names from other scopes in the same translation unit.
— When a name has no linkage, the entity it denotes cannot be referred to by names from other scopes.

---

So if you can't name it in another translational unit then its not external linkage. But don't take my word for it:

Quote:

---

Originally Posted by 3.5.4

4 A name having namespace scope has external linkage if it is the name of
— an object or reference, unless it has internal linkage; or
— a function, unless it has internal linkage; or
— a named class (clause 9), or an unnamed class defined in a typedef declaration in which the class has the typedef name for linkage purposes (7.1.3); or
— a named enumeration (7.2), or an unnamed enumeration defined in a typedef declaration in which the enumeration has the typedef name for linkage purposes (7.1.3); or
— an enumerator belonging to an enumeration with external linkage; or
— a template, unless it is a function template that has internal linkage (clause 14); or
— a namespace (7.3), unless it is declared within an unnamed namespace.

---

Note: All bolding mine

refer to

Quote:

---

Originally Posted by 14.3.2
A template-argument for a non-type, non-template template-parameter shall be one of;
- an integral constant-expression of integral or enumeration type; or
- the name of a non-type template-parameter; or
- the name of an object or function with external linkage, including function templates and function template-ids but excluding non-static class members. expressed as & id-expression where the & is optional if the name refers to a function or array; or
- a pointer to member expressed as described in 5.3.1

---

what about this code

Code:

---

namespace {
  char buffer_external[256];      //external linkage
  static char buffer_internal[256];  //internal linkage
};

template<char* P> class X{};

int main()
{
  X<buffer_external> x;  //it's OK,
  X<buffer_internal> y;    //error, buffer_internal has not external linkage
}

---

if buffer_external has internal linkage, how can be X<buffer_external> legal ?

an unnamed namespace restricts the visibility of its members to the scope of the translation unit by means of name mangling, it doesn't necessarily guarantee internal linkage

I'm done with this. Anyone else want to try?

nah not worth the energy.