Est-il possible d'allouer dynamiquement une variable temporaire en C++?

Question

Est-il possible d'allouer dynamiquement une variable temporaire en C++?
Je veux faire quelque chose comme ça:

#include <iostream> 
#include <string> 

std::string* foo() 
{ 
    std::string ret("foo"); 
    return new std::string(ret); 
} 

int main() 
{ 
    std::string *str = foo(); 
    std::cout << *str << std::endl;                           
    return 0; 
} 

Ce code fonctionne, mais le problème est que je dois créer une autre chaîne afin de le retourner comme un pointeur. Y at-il un moyen de mettre ma variable temporaire/locale dans mon tas sans recréer un autre objet?
Voici une illustration de la façon dont je le ferais:

std::string* foo() 
{ 
    std::string ret("foo"); 
    return new ret; // This code doesn't work, it is just an illustration 
} 

Answer 1

Eh bien oui, il y a, on parle de pointeurs intelligents:

#include <memory> 
std::unique_ptr<std::string> foo() 
{ 
    return std::unique_ptr<std::string>("foo"); 
} 

// Use like this: 
using namespace std; 
auto s = foo();  // unique_ptr<string> instead of auto if you have an old standard. 
cout << *s << endl; // the content pointed to by 's' will be destroyed automatically 
        // when you stop using it 

Modifier : sans changer le type de retour:

std::string* foo() 
{ 
    auto s = std::unique_ptr<std::string>("foo"); 
    // do a lot of stuff that may throw 

    return s.release(); // decorellate the string object and the smart pointer, return a pointer 
         // to the string 
} 

Answer 2

Que diriez-vous ceci:

std::string* foo() 
{ 
    std::string * ret = new std::string("foo"); 
    // do stuff with ret 
    return ret; 
}