Re: Type visibility
On Aug 4, 12:32 pm, "saneman" <as...@asd.com> wrote:
I have made two modules:
1) main.cpp
Contains a main function and struct P.
Includes head.h and std::vector
#include "head.h"
#include<vector>
#include<iostream>
struct P {
int x;
int y;
};
int main() {
typedef std::vector<P> container;
container v;
P p;
p.x = 22;
p.y = 33;
v.push_back(p);
A<container> a(v);
int res = a.getValue();
std::cout << res << std::endl;
return 0;
}
2) head.h
A header file that contains the class A.
template <typename T >
class A {
public:
T t;
A(T t_){
t = t_;
}
int getValue() {
int res = (*t.begin()).x;
return res;
}
};
In class A getValue() returns the x field of the struct
defined in main.cpp. But how does class A know about the type
'P' which is only created in main?
As Pete said, there is no class A, only a class template A (and
later, a class A<container>). When parsing a template
definition, the compiler divides all names and expressions into
dependent and non-dependent; anything which is dependent only
gets looked up when the template is instantiated. The rules as
to when something is dependent, and when it's not, are fairly
complicated, as are the rules concerning dependent name look-up.
I'd suggest you get a good book about templates, such as "C++
Templates: the Complete Guide" (by Vandevoorde and Josuttis),
and study it carefully.
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34