Does default-initializing a non-const reference function parameter from a dynamically allocated dereferenced pointer create a memory leak?

Question

I'm in front of this and will have to deal with C++98, possibly C++03, and C++11 :

type1 myfunc( type2& var = /*some value of type "type2"*/ )
{
   // Some code
}

I tried this :

type1 myfunc( type2& var = *(new type2) )
{
   // Some code
}

And of course it works, but I'm not sure wether this creates or not a memory leak. What does this code exacty do in the computer memory ? If I can't do this, do I have any other solutions than to overload my function?

Answer 1

The question is tagged C++11, so I suppose you can use std::unique_ptr to solve this problem.

A little example

#include <memory>
#include <iostream>

std::size_t myfunc( std::string const & var
   = * std::unique_ptr<std::string>(new std::string("default string")) )
{ return var.size(); }

int main ()
 {
   std::cout << "default:  " << myfunc() << std::endl;
   std::cout << "argument: " << myfunc("no default") << std::endl;

   return 0;
 }

Hoping this helps.

--- added C++98/C++03 solution ---

Isn't clear what language the OP want to use.

In case of C++98/C++03, it's possible to use std::auto_ptr instead of the C++11 std::unique_ptr.

I remember that std::auto_ptr is deprecated from C++11, so use it only if you can't use C++11 (or a newer standard)

The following example should be C++98 compliant (I've removed the const too)

#include <memory>
#include <iostream>

std::size_t myfunc(std::string & var
   = * std::auto_ptr<std::string>(new std::string("default string")) )
{ return var.size(); }

int main ()
 {
   std::string noDef("no default");

   std::cout << "default:  " << myfunc() << std::endl;
   std::cout << "argument: " << myfunc(noDef) << std::endl;

   return 0;
 }

Answer 2

If you allocate memory and don't delete it you have a memory leak, regardless of the shenanigans you pull with dereferencing, references, or pointer manipulations.

Answer 3

This code will create a memory leak in situations when the default parameter is used, unless myfunc frees it (which would be a hack):

type1 myfunc( type2& var = *(new type2) ) {
   // Some code
   delete &var; // Very bad, don't do it like that.
}

When the call is made with a parameter specified for the var, there would be no memory leak without the delete. This is because the compiler sees that you are passing an argument for the reference parameter, and not allocate new type2.

One approach to create a default reference without making a memory leak is to define a static throw-away variable, and use it as a reference:

static type2 throwaway;
type1 myfunc( type2& var = throwaway ) {
    // Some code
}

This way the callers who do not need to see modifications done to var would be able to call your function without specifying a reference for it. Of course if myfunc makes any modifications to var, the callers would not be able to see them.