Bypassing constructor in C++

Question

I am attempting to use C++ for AVR programming using gcc-avr. The main issue is that there is no libc++ available and the implementation does not define any of the new or delete operators. Similarly there is no header to include using placement new is not an option.

When attempting to allocate a new dynamic object I am tempted to just do this:

Class* p = reinterpret_cast<Class*>(malloc(sizeof(Class)));
p->Init();

where Init() manually initializes all internal variables. But is this safe or even possible?

I have read that object construction in C++ is somewhat complex but without new or delete how do I initialize a dynamically allocated object?

To expand on the above question.

Using standard g++ and placement new it is possible to subvert constructors in two ways, assuming that C++ uses the same straightforward ways of alligning memory as C (code example below).

Using placement new to initialize any allocated memory.
Initialize allocated memory directly using class methods.

Of course this only holds if the assumptions are true that:

Memory layout of an object is fixed at compile time.
Memory allocation is only concerned with class variables and observers normal C rules (allocated in order of declaration aligned to memory boundary).

If the above holds could I not just allocated memory using malloc and use a reinterpret_cast to convert to the correct class and initialize it manually? Of course this is both non-portable and hack-ish but the only other way I can see is to work around the problem and not use dynamically allocated memory at all.

Example:

Class A {
    int i;
    long l;
    public:
        A() : i(1), l(2) {}
        int get_i() { return i; }
        void set_i(int x) { i = x; }
        long get_l() { return l; }
        void set_l(long y) { l = y; }
};

Class B {
     /* Identical to Class A, except constructor. */
     public B() : i(3), l(4) {}
};

int main() {
     A* a = (A*) ::operator new(sizeof(A));
     B* b = (B*) ::operator new(sizeof(B));

     /* Allocating A using B's constructor. */
     a = (A*) new (a) B();

     cout << a->get_i() << endl; // prints 3
     cout << a->get_l() << endl; // prints 4

     /* Setting b directly without constructing */
     b->set_i(5);
     b->set_l(6);

     cout << b->get_i() << endl; // prints 5
     cout << b->get_l() << endl; // prints 6

My suggestion would be to look at a implementation of new (e.g. in libc++) and copy that into your project. — MikeMB, Apr 04 '15 at 20:53
Space allocated by `malloc` may not be properly initialized. So `p->Init()` may cause an error. — , Apr 04 '15 at 20:54
If you want a c++ way you should skip `malloc` and do `Class* p = ::operator new(sizeof(Class));`. I'm pretty sure that won't call the constructor. But I think `delete` always will call the destructor. — Andreas Vennström, Apr 04 '15 at 21:02
@AndreasVennström The problem with that is that I get a linker error with 'undefined reference to operator new(unsigned int)' so that's not an option. — Kenneth, Apr 04 '15 at 21:07
As long as the compiler supports placement new syntax, it's trivial to define a placement new operator. Just return the argument. Have you tried it? — Cheers and hth. - Alf, Apr 04 '15 at 21:10
Given that avr-gcc is really a cut down C compiler, why are you trying to program C++ with it? — Peter, Apr 04 '15 at 21:27
it might be easier just not use dynamic allocation on objects — user3528438, Apr 04 '15 at 22:36
@Cheersandhth.-Alf Yes. I thought I had included that in my question but on a readthrough that had somehow turned to garbage. I clarified it above. There is no new header to include so placement new is not an option. — Kenneth, Apr 05 '15 at 11:24
@Peter Avr-gcc does provide a g++ option for compilation and with C++11s new features (constexpr, move semantics, auto, decltype, etc.) it seems like a good time to see how C++ as a base language compares in an AVR environment. — Kenneth, Apr 05 '15 at 11:27
So, your problem is that the library, even though the compiler claims to support C++, does not have `operator new` (which means it does not support C++), yes? There's nothing magical about `operator new`, and it may be well worth just rolling your own. For a longer discussion, see http://stackoverflow.com/questions/7194127/how-should-i-write-iso-c-standard-conformant-custom-new-and-delete-operators — Christopher Creutzig, Apr 05 '15 at 11:44
@ChristopherCreutzig That is an awesome explanation but it only details memory allocation. It does not explain instantiation at all. Furthermore it make use of both ::operator new and delete which are not available on this implementation. I have made a small example abusing some of the information from the article and updated the question with it. — Kenneth, Apr 05 '15 at 13:27
By providing `A::operator new` etc., you should be able to simply use the usual idioms like `auto a = std::make_unique()` or older-style `A* a = new A();`. There is hardly ever a reason to invoke `operator new` explicitly; if you do, yes, you need placement new to go through the constructors properly. Trying to put that off into some `Init` method won't work properly if you add in inheritance and exceptions. (At least not without a *lot* of work. Obviously it would be possible somehow, C++ being Turing-complete ...) — Christopher Creutzig, Apr 05 '15 at 19:55
@ChristopherCreutzig That was it! Defining operator new on the class allowed for the 'older-style' allocation of A. Can you create an answer with that so I can except it. — Kenneth, Apr 05 '15 at 20:54

score 2 · Accepted Answer · edited May 23 '17 at 12:22

If your allegedly C++ compiler does not support operator new, you should be able to simply provide your own, either in the class or as a global definition. Here's a simple one from an article discussing operator new, slightly modified (and the same can be found in many other places, too):

void* operator new(size_t sz) {
    void* mem = malloc(sz);
    if (mem)
        return mem;
    else
        throw std::bad_alloc();
}


void operator delete(void* ptr) {
    free(ptr);
}

A longer discussion of operator new, in particular for class-specific definitions, can also be found here.

From the comments, it seems that given such a definition, your compiler then happily supports the standard object-on-heap creations like these:

auto a = std::make_shared<A>();
A *pa = new A{};

The problem with using Init methods as shown in the code snippet in your question is that it can be a pain to get that to work properly with inheritance, especially multiple or virtual inheritance, at least when something during object construction might throw. The C++ language has elaborate rules to make sure something useful and predictable happens in that situation with constructors; duplicating that with ordinary functions probably will get tricky rather fast.

Good explanation. I'll just add that there are lots more things that avr-g++ does not do besides new and delete. These include exceptions in any form and the entire libc++ library (class, functions, templates, etc.). It's summarized here: http://www.atmel.com/webdoc/AVRLibcReferenceManual/FAQ_1faq_cplusplus.html — Kenneth, Apr 06 '15 at 11:43

score 1 · Answer 2 · answered Apr 06 '15 at 08:15

Whether you can get away with your malloc()-reinterprete_cast<>-init() approach depends on whether you have virtual functions/inheritance. If there is nothing virtual in your class (it's a plain old datatype), your approach will work.

However, if there is anything virtual in it, your approach will fail miserably: In these cases, C++ adds a v-table to the data layout of your class which you cannot access directly without going very deep into undefined behavior. This v-table pointer is usually set when the constructor is run. Since you can't safely mimic the behavior of the constructor in this regard, you must actually call a constructor. That is, you must use placement-new at the very least.

Providing a classless operator new() as Christopher Creutzig suggests, is the easiest way to provide full C++ functionality. It is the function that is used internally by new expressions to provide the memory on which the constructors can be called to provide a fully initialized object.

One last point of assurance: as long as you do not use a variable length array at the end of a struct like this

typedef struct foo {
    size_t arraySize;
    int array[];
} foo;

the size of any class/struct is entirely a compile time constant.

Bypassing constructor in C++

2 Answers2