c++ - float - invalid operands of types const char 3 and int to binary operator &''

Error: operandos no válidos de los tipos ''const char[35]'' y ''const char[2]'' para binary ''operator+''

Question

En la parte superior de mi archivo tengo

#define AGE "42"

Más adelante en el archivo, uso la identificación varias veces, incluidas algunas líneas que parecen

1 std::string name = "Obama";
2 std::string str = "Hello " + name + " you are " + AGE + " years old!";
3 str += "Do you feel " + AGE + " years old?";

Me sale el error

"error: operandos no válidos de los tipos ''const char [35]'' y ''const char [2]'' to binary ''operator +''"

en la línea 3. Investigué un poco y descubrí que era debido a cómo C ++ estaba tratando las diferentes cadenas y podía corregirlo cambiando "AGE" por "string (AGE)". Sin embargo, accidentalmente me perdí una de las instancias hasta el día de hoy y me preguntaba por qué el compilador no se quejaba a pesar de que todavía tenía una instancia en la que solo era "EDAD".

A través de algunas pruebas y errores, descubrí que solo necesito una string(AGE) en las líneas en las que no concatene otra cadena que se creó en el cuerpo de la función.

Mis preguntas son "qué sucede en segundo plano que a C ++ no le gusta concatenar una cadena con una cadena que el preprocesador puso allí a menos que también esté concatenando una cadena que definió en la función".

Answer 1

Considera esto:

std::string str = "Hello " + "world"; // bad!

Tanto los rhs como los lhs para operator + son char* s. No hay una definición de operator + que tome dos caracteres char* (de hecho, el idioma no le permite escribir uno). Como resultado, en mi compilador esto produce un error de "no se pueden agregar dos punteros" (el tuyo aparentemente expresa las cosas en términos de matrices, pero es el mismo problema).

Ahora considera esto:

std::string str = "Hello " + std::string("world"); // ok

Hay una definición de operator + que toma un const char* como lhs y una std::string estándar como rhs, por lo que ahora todos están contentos.

Puede extender esto a una cadena de concatenación tan larga como desee. Sin embargo, se puede ensuciar. Por ejemplo:

std::string str = "Hello " + "there " + std::string("world"); // no good!

Esto no funciona porque está intentando hacer + dos caracteres char* s antes de que lhs se haya convertido a std::string . Pero esto está bien:

std::string str = std::string("Hello ") + "there " + "world"; // ok

Porque una vez que haya convertido a std::string , puede + tantos caracteres adicionales como desee.

Si eso sigue siendo confuso, puede ser útil agregar algunos corchetes para resaltar las reglas de asociatividad y luego reemplazar los nombres de las variables con sus tipos:

((std::string("Hello ") + "there ") + "world");
((string + char*) + char*)

El primer paso es llamar al string operator+(string, char*) , que se define en la biblioteca estándar. Reemplazando esos dos operandos con su resultado da:

((string) + char*)

Que es exactamente lo que acabamos de hacer, y que sigue siendo legal. Pero intente lo mismo con:

((char* + char*) + string)

Y estás atascado, porque la primera operación intenta agregar dos caracteres char* s.

La moraleja de la historia: si desea asegurarse de que funcionará una cadena de concatenación, asegúrese de que uno de los dos primeros argumentos sea explícitamente de tipo std::string .

Answer 2

En este caso particular, una solución aún más simple sería simplemente deshacerse del "+" todos juntos porque AGE es un literal de cadena y lo que viene antes y después también son literales de cadena. Podrías escribir la línea 3 como:

str += "Do you feel " AGE " years old?";

Esto se debe a que la mayoría de los compiladores de C / C ++ concatenarán los literales de cadena automáticamente. Lo anterior es equivalente a:

str += "Do you feel " "42" " years old?";

que el compilador convertirá a:

str += "Do you feel 42 years old?";

Answer 3

En la línea 2, hay un std::string involucrado ( name ). Hay operaciones definidas para char[] + std::string , std::string + char[] , etc. "Hello " + name da un std::string , que se agrega a " you are " , dando otro string, etc.

En la línea 3, estás diciendo

char[] + char[] + char[]

y no se puede simplemente agregar matrices entre sí.

Answer 4

No puedes concatenar cadenas crudas como esta. operator+ solo funciona con dos objetos std::string o con un std::string y una cadena sin formato (a cada lado de la operación).

std::string s("...");
s + s; // OK
s + "x"; // OK
"x" + s; // OK
"x" + "x" // error

La solución más fácil es convertir tu cadena en bruto en una std::string primero:

"Do you feel " + std::string(AGE) + " years old?";

Por supuesto, no debes usar una macro en primer lugar. C ++ no es C. Use const o, en C ++ 11 con el soporte adecuado del compilador, constexpr .

Answer 5

Tuve el mismo problema en mi código. Estaba concatenando una cadena para crear una cadena. A continuación se muestra la parte del código.

int scannerId = 1;
std:strring testValue;
strInXml = std::string(std::string("<inArgs>" /
                        "<scannerID>" + scannerId) + std::string("</scannerID>" /
                        "<cmdArgs>" /
                        "<arg-string>" + testValue) + "</arg-string>" /
                        "<arg-bool>FALSE</arg-bool>" /
                        "<arg-bool>FALSE</arg-bool>" /
                        "</cmdArgs>"/
                        "</inArgs>");

Answer 6

AGE se define como "42" por lo que la línea:

str += "Do you feel " + AGE + " years old?";

se convierte a:

str += "Do you feel " + "42" + " years old?";

Lo cual no es válido ya que "Do you feel " y "42" son const char[] . Para resolver esto, puedes hacer que una sea std::string , o simplemente eliminar el + :

// 1.
str += std::string("Do you feel ") + AGE + " years old?";

// 2.
str += "Do you feel " AGE " years old?";