will compiler reserve memory for this object?

Question

I have following two classes:

template <size_t size>
class Cont{
 public:
 char charArray[size];
};
template <size_t size>
class ArrayToUse{
 public:
 Cont<size> container;
 inline ArrayToUse(const Cont<size+1> & input):container(reinterpret_cast<const Cont<size> &>(input)){}
};

I have three following lines of code at global scope:

const Cont<12> container={"hello world"};
ArrayToUse<11> temp(container);
char (&charArray)[11]=temp.container.charArray;

In totality of my code The only usage of "container" object is for initialization of an object of "ArrayToUse" class as mentioned and after initialization of "charArray" reference to "temp.container.charArray" I'll use that reference in rest of my code, now I'm wondering does compiler reserve memory for "container" object since that's got a temporary usage?

Answer 1

it totaly depends on your particular compiler so i'd say inspect the assembly and find out! the compiler could optimize container out, or it could neglect to do so.

Answer 2

Any variable defined at global scope has memory reserved for it at compile time. That does not mean it's guaranteed to be properly initialized, but it's there all the same.

At link-time, Visual C++ offers the option to strip unused data and functions via /OPT - see here.

Answer 3

The compiler should create the container variable in the compiled object file. The linker is the one that can tell if it's needed or not (for an exported symbol, or from another compilation unit if declared extern).

But...

The type Cont<x> is unrelated to Cont<x+1>. You cannot depend on the memory of a member variable being layed out in similar fashions. Heck, you cannot even know if it looks the same, since there is this thing called 'template specialization':

// your code
template <size_t size>
class Cont{
 public:
 char charArray[size];
};

// my evil tweak
// I'm the worst compiler ever but I feel that this
// array would better be represented as a map...
template<> class Cont<12> {
   std::map<int,char> charArray;
};

// your screwed up result
Cont<12> c12;
Cont<11>& c11( reinterpret_cast<Cont<11>&>(c12) );
char (&s11)[11] = c11.charArray; // points to the first byte of a list object...

EDIT -- @UncleBen's comment insinuates I'm overdoing here. And he's right.

according to wikipedia,

• A pointer to a POD-struct object, suitably converted using a reinterpret cast, points to its initial member and vice versa, implying that there is no padding at the beginning of a POD-struct.

So in this case,

• where the charArray is the first member of a Cont<n>, and there are no non-POD members

• there is no assignment operator, nor a destructor

It is safe.