Re: Support for export keyword ?
"io_x" <a@b.c.invalid> ha scritto nel messaggio
news:4b5bf9f5$0$823$4fafbaef@reader5.news.tin.it...
"Juha Nieminen" <nospam@thanks.invalid> ha scritto nel messaggio
news:hjbs6r$1fbc$1@adenine.netfront.net...
James Kanze wrote:
To instantiate a template at link time, you
need to reconstitute the environment of the point of
instantiation, which isn't necessarily trivial.
Could you give some examples of the difficulties which pop up with that?
One would think that it wouldn't be so much different as when the
programmer does the same thing "manually". In other words, when the
programmer/linker sees that a template is instantiated with type X, the
programmer/linker goes to the source file where the template is defined
and adds an explicit instantiation of it for X and then recompiles that
one object file,
don't know, not i know somthing well, but i have one idea:
for example:
template <typename T> class Image{
public:
unsigned height;
unsigned width;
T* pxs;
Image(int h, int w)
{int i, g;
height=0; width=0; pxs=0;
if(w<=0||h<=0) return;
g =h*sizeof(T);
if(g<=0) return;
g*=w;
if(g<=0) return;
cout << "Size=" << g << "\n";
pxs=(T*) malloc(g);
if(pxs==0) return;
height=h; width=w;
}
~Image(){free(pxs);}
};
has to be compiled like
class Image{
public:
unsigned height;
unsigned width;
generictypeT* pxs; // or char* pxs;
Image(unsigned sizeof_T, int h, int w)
Image(unsigned* arg, unsigned* argsz, int h, int w)
where arg[0]==sizeof_T
we know that the element0_ofT has address == &T
arsz[0]==sizeof(element_0ofT)
arg[1]==offsetof(element_1ofT) arsz[1]==sizeof(element_1ofT)
arg[2]==offsetof(element_2ofT) arsz[2]==sizeof(element_2ofT)
etc etc
arg[n-1]==offsetof(element_n-1ofT) arsz[n-1]==sizeof(element_n-1ofT)
arg[n] == 0 // for see the end put 0
// the elements of struct are 0..n-1
{int i, g;
height=0; width=0; pxs=0;
if(w<=0||h<=0) return;
g =h*sizeof_T;
if(g<=0) return;
g*=w;
if(g<=0) return;
cout << "Size=" << g << "\n";
pxs=(generictypeT*) malloc(g);
if(pxs==0) return;
height=h; width=w;
}
~Image(){free(pxs);}
}
and the compiler has to use the funtions in this way
Image<double> g(768, 1024);
call the constructor:
Image(sizeof(double), 768, 1024)
unsigned p[]={sizeof(double), 0}, q[]={sizeof(double), 0}
Image(p, q, 768, 1024);
so all the routines that use the generic type
(that has to use sizeof(T)) can be ok
like above if pass sizeof(T)
and that's about it. It just sounds like all the linker
needs is to call the compiler to compile the necessary object file,
telling the compiler "and instantiate this template for X". Then the
compiler does that, and the linker proceeds with the new object file as
normal.
(Of course this ties the linker tightly to the compiler, removing
their current separation and independence, but... who actually uses this
separation nowadays, really? Most compilers are also their own linkers
at the same time.)
--- news://freenews.netfront.net/ - complaints: news@netfront.net ---