Thread: C++ std routines

>>Due to the complexity of the feature, though, no compiler I'm aware of fully implements it.
>>But if one did, it could use a standard library where the linker resolves std::vector.
Can you explain me why it is complex?
[EDIT]
From the posts I got, I made another question: Does C Standard Liberary use Windows API to do its work in Windows environment?

Does C Standard Liberary use Windows API to do its work in Windows environment?

The short answer is yes. The long answer is that the source code for the c standard library is probably on your machine, check: C:\Program Files\Microsoft Visual Studio .NET 2003\Vc7\crt\src, or some similar directory, depending on which version of Visual Studio you are running.

Originally Posted by siavoshkc

Can you explain me why it is complex?

The classical compile process looks like this: first, you take each .cpp file, preprocess it (and thus add all the .h files) and compile it to an object file (.o or .obj, typically).
Then, you take these object files and link them together.

With the extern template feature, this doesn't work. The compiler needs to instantiate templates, and it needs to know about the usage of the templates to know with which types to instantiate them. That's why, currently, all code of templates must be in the headers: so that the compiler can instantiate them upon their use.
If you want to have them in completely independent files, the compiler must keep statistics about which templates are implemented where, and how they are used. Upon each template use, the compiler would have to find out where the template is implemented, see if it has already been instantiated with that specific type, if it hasn't been, parse the template implementation and instantiate it, then record the instantiation in the statistics. Or alternatively, it could, upon coming across a template implementation, save it to a temporary file, upon encountering an instantiation log that, and after everything else is done, look at the instantiation log and create all instantiations. Of course, if one of the templates in turn uses another, that must be handled too.

So you see, it's a significant deviation from the current model and thus very complex to implement. And leaving aside the compiler and linker themselves, you have to consider build tools that need to handle all those files the compiler generates: does it create one object file per instantiation, or one object file for all instantiations of a template? What should be done with the statistics files?

And I'm still oversimplifying. Only those parts of a template class that are actually used get instantiated. A compiler must record each single function individually, not whole template classes at once.

That's what I can tell you from the viewpoint of a C++ programmer who excels in theory and has done a bit of compiler development - a real compiler developer could probably tell you even more.

Thanks CornedBee.
I will look at /src.