C++ invalid operands of types ‘char*’ and ‘const char [2]’ to binary ‘operator+’

c++charconstantsvisual-studio-2010

the compiler return me the error "invalid operands of types 'char*' and 'const char [2]' to binary 'operator+'" when trying to do this simple code:

BodyText[client] = PS3::ReadString(0x0178646c) + "\n" ;

Here my ReadString() function:

char returnRead[100];
char* ReadString(int address)
{
    memset(&returnRead[0], 0, sizeof(returnRead));
    int strlength = 100;
    char* StrBytes = ReadBytes(address, strlength);
    for (int i = 0; i < strlength; i++)
    {
        if (StrBytes[i] != 0x00)
            returnRead[i] = StrBytes[i];
    else
        break;
}
return returnRead;
}

Thanks anyway for reading

Best Solution

This is because there is no operator+ for char* (the return-type of your function) and const char[2] (the type of "\n"), and since you cannot overload operators for built-in types, there cannot be one. Since this question is tagged C++:

Just use std::string instead of char*, all your problems are solved already. std::string will be superior to the hacks you try to do.

Here you can find a overview over strings features and examples how to use them. You then can concatenate strings a,b,c like std::string new_string = a + b + c;

Related Solutions

C# – the difference between const and readonly in C#

Apart from the apparent difference of

having to declare the value at the time of a definition for a const VS readonly values can be computed dynamically but need to be assigned before the constructor exits.. after that it is frozen.
const's are implicitly static. You use a ClassName.ConstantName notation to access them.

There is a subtle difference. Consider a class defined in AssemblyA.

public class Const_V_Readonly
{
  public const int I_CONST_VALUE = 2;
  public readonly int I_RO_VALUE;
  public Const_V_Readonly()
  {
     I_RO_VALUE = 3;
  }
}

AssemblyB references AssemblyA and uses these values in code. When this is compiled:

in the case of the const value, it is like a find-replace. The value 2 is 'baked into' the AssemblyB's IL. This means that if tomorrow I update I_CONST_VALUE to 20, AssemblyB would still have 2 till I recompile it.
in the case of the readonly value, it is like a ref to a memory location. The value is not baked into AssemblyB's IL. This means that if the memory location is updated, AssemblyB gets the new value without recompilation. So if I_RO_VALUE is updated to 30, you only need to build AssemblyA and all clients do not need to be recompiled.

So if you are confident that the value of the constant won't change, use a const.

public const int CM_IN_A_METER = 100;

But if you have a constant that may change (e.g. w.r.t. precision).. or when in doubt, use a readonly.

public readonly float PI = 3.14;

Update: Aku needs to get a mention because he pointed this out first. Also I need to plug where I learned this: Effective C# - Bill Wagner

C++ – How to convert a std::string to const char* or char*

If you just want to pass a std::string to a function that needs const char* you can use

std::string str;
const char * c = str.c_str();

If you want to get a writable copy, like char *, you can do that with this:

std::string str;
char * writable = new char[str.size() + 1];
std::copy(str.begin(), str.end(), writable);
writable[str.size()] = '\0'; // don't forget the terminating 0

// don't forget to free the string after finished using it
delete[] writable;

Edit: Notice that the above is not exception safe. If anything between the new call and the delete call throws, you will leak memory, as nothing will call delete for you automatically. There are two immediate ways to solve this.

boost::scoped_array

boost::scoped_array will delete the memory for you upon going out of scope:

std::string str;
boost::scoped_array<char> writable(new char[str.size() + 1]);
std::copy(str.begin(), str.end(), writable.get());
writable[str.size()] = '\0'; // don't forget the terminating 0

// get the char* using writable.get()

// memory is automatically freed if the smart pointer goes 
// out of scope

std::vector

This is the standard way (does not require any external library). You use std::vector, which completely manages the memory for you.

std::string str;
std::vector<char> writable(str.begin(), str.end());
writable.push_back('\0');

// get the char* using &writable[0] or &*writable.begin()