How to optimize object return in C++?
===

Consider the code bellow.

    // Consider that MyObject receives three integers in it's constructor.
    MyObject createObject()
    {
        MyObject result(1, 2, 3);
        return result;
    }

As long as I know, when you return an object in C++(like in this function), the compiler will create a new object(as a local variable) in the stack for the client. In this exemple, it will be a new `MyObject` object that will be created using the copy constructor with `result` as parameter. This implies in redundant processing for the machine: the object `result` will be created in the stack and then a second object will be created and returned.
An alternative to avoid this is creating the object dynamically(not in stack) and then return it's pointer. But it will cause memory leak or force the client to delete the object after use. So, the solution I found was to use an smart pointer, like this:


    // Consider that MyObject receives three integers in it's constructor.
    boost::smart_ptr<MyObject> createObject()
    {
        boost::smart_ptr<MyObject> result(new MyObject(1, 2, 3));
        return result;
    }

This works, but the smart pointer still is an object that will be recreated(even if the cost is low becouse, basically, it holds just a pointer). I was guessing if there's a way to do this a more easily; or if there wasn't a way already implemented by the compiler to optimize this work or something alike. Is there a syntax to say to the compiler to do what I want?