Printable View
Suppose you made a really complicated template class, and you use it with many kinds of arg types. For example, set<Blah*>, set<Bloo*>, set<Moo*>, set<Mooya*> etc.
But all the arg types are essentially pointer types.
When compiled, will each of these instantiations have its own code template (aka get really bloated), or will each of these templates share a same code when compiled (set<void*>)?
Depends on the implementation. STLport is the only one that I know that enables this kind of optimizations, and I don't think the standard mandates it. Besides, there are limitations on the compilers that support it and on what you can accomplish with it. From STLport's user_config.h:
Quote:
To reduce the famous code bloat trouble due to the use of templates STLport grant
a specialization of some containers for pointer types. So all instanciations
of those containers with a pointer type will use the same implementation based on
a container of void*. This feature has shown very good result on object files size
but after link phase and optimization you will only experiment benefit if you use
many container with pointer types.
There are however a number of limitation to use this option:
- with compilers not supporting partial template specialization feature, you won't
be able to access some nested container types like iterator as long as the
definition of the type used to instanciate the container will be incomplete.
- you won't be able to use complex Standard allocator implementations which are
allocators having pointer nested type not being a real C pointer.
Hmm.. I see. Any idea on whether g++ supports this? I just went to IRC and some guy started saying that: pointers can be of different sizes. I'm hoping this can be known during compile time?
Pointers are always the same size on the same machine, even across different types. The size of a char * pointer will always be the same size as a std::map<std::string, std::vector<std::string> > * pointer.
After all, a pointer is simply a variable that stores a memory address as a value. You can, therefore, get the size of a pointer with sizeof(). For example:
Does that help at all?Code:#include <iostream>
int main(int argc, char *argv[]) {
std::cout << "On this system, the size of a pointer is: " << sizeof(char *) << std::endl;
return 0;
}
No idea, to be honest. I seldom use libstdc++Quote:
Originally Posted by underthesun
Yes, this is technically true. However, platforms where this is the case are extremely rare, and furthermore, all pointers can be cast to and from void* (Function and method pointers nonwithstanding). So as long as the underlying container holds the pointer types as void*, there should be no problem.Quote:
I just went to IRC and some guy started saying that: pointers can be of different sizes
Yeah, I thought that was a bit weird how he said it like that. That guy also said that void* is required to be able to contain the value of a pointer in any object.. anyhow I guess I'll start taking things with a grain of salt now.
I will quote (from here):
Interesting . . .Quote:
558 A pointer to void shall have the same representation and alignment requirements as a pointer to a character type.
559 Similarly, pointers to qualified or unqualified versions of compatible types shall have the same representation and alignment requirements.
560 All pointers to structure types shall have the same representation and alignment requirements as each other.
561 All pointers to union types shall have the same representation and alignment requirements as each other.
I can say that I've never run into a platform where pointer sizes are different, though . . . Well, you learn something every day.
whoops, that reply was late. Anyhow, yeah, you do learn something new everyday :) would be a nice trick question hahaha
Me neither, but it's one of many technicalities present in the C/C++ standard. It's like the definition of a "byte"; neither language says that it HAS to be 8 bits... yet, platforms in which it isn't are a rare corner case.Quote:
Originally Posted by strange