std::string s = std::string("foo");
Esto crea un objeto temporal std::string
que contiene "foo", entonces lo asigna a s
. (Tenga en cuenta que los compiladores pueden eludir el temporal. El elison temporal en este caso se permite explícitamente por norma el C++.)
std::string s = new std::string("foo");
Este es un error de compilación. La expresión new std::string("foo")
crea un std::string
en la tienda gratuita y devuelve un puntero a std::string
. A continuación, intenta asignar el puntero devuelto del tipo std::string*
al s
del tipo std::string
. El diseño de la clase std::string
impide que eso suceda, por lo que la compilación falla.
C++ no es Java. Esta no es la forma en que normalmente se crean los objetos, porque si olvida delete
el objeto devuelto std::string
se perderá la memoria. Uno de los principales beneficios del uso de std::string
es que administra automáticamente el buffer de cadena subyacente, por lo que new
-destruye ese propósito.
std::string s = "foo";
Esto es esencialmente lo mismo que # 1. Inicializa técnicamente una nueva cadena temporal que contendrá "foo" y la asignará al s
. Una vez más, los compiladores normalmente eludirán los compiladores temporales (y de hecho casi todos los compiladores no estúpidos hoy en día lo hacen, de hecho, eliminar el temporal), por lo que en la práctica simplemente construye un nuevo objeto llamado s
en su lugar.
Específicamente invoca un constructor de conversión en std::string
que acepta un argumento const char*
. En el código anterior, se requiere que el constructor de conversión sea no explicit
; de lo contrario, se trata de un error del compilador. El constructor de conversión es, de hecho, no explicit
para std::string
s, por lo que lo anterior se compila.
Así es como std::string
s suelen ser inicializados. Cuando s
sale del alcance, el objeto s
se destruirá junto con el almacenamiento intermedio de cadenas subyacente. Tenga en cuenta que lo siguiente tiene el mismo efecto (y es otra forma típica en que se inicializan std::string
s), en el sentido de que también produce un objeto llamado s
que contiene "foo".
std::string s("foo");
Sin embargo, there's a subtle difference between std::string s = "foo";
and std::string s("foo");
, una de ellas es que el constructor de conversión puede ser explicit
o no explicit
en el caso anterior.
Tenga en cuenta que generalmente desea utilizar la opción 4: 'std :: string s (" foo ");' –
@JerryCoffin: ¿cómo es eso diferente de la opción 3? –
@MikeSeymour: inicializa directamente la inicialización en lugar de la inicialización de la copia. Al menos conceptualmente, # 3 crea una cadena temporal inicializada a partir de la constante suministrada, luego utiliza el constructor de copia para crear 's' a partir de ese valor (aunque, ciertamente, el compilador normalmente lo omitirá y hará el equivalente a la inicialización directa). –