C ++-无法从'char []'转换为'char []'

Question

So I am very new to C++, and having a background in dynamic languages this is probably a newbie question. I was trying to write an age-old exercise, see below:

class Person
{
public:
    Person(char n[], int a) {           
        name = n;
        age = a;
    }

    int age;
    char name[];

};

int main(int argc, char const *argv[])
{
    Person p("John", 25);
    return 0;
}

This throws the error:

main.cpp(8) : error C2440: '=' : cannot convert from 'char []' to 'char []'
        There are no conversions to array types, although there are conversions
to references or pointers to arrays

Why does it need to convert from the same type? This is my full code and full error, by the way. Any help is appreciated!

Answer 1

There is a type called char [] , but it's an incomplete array type which is a somewhat advanced topic. If it were compiling in strict mode, the compiler would have reported that an incomplete array cannot be a class member, and that should prevent the error you got. But actually you stumbled upon a GCC extension which is seldom compatible with C++ as it requires memory allocation by malloc .

Anyway, C++ does indeed have variable-length strings in the library, albeit not as a "native" type. You need to include <string> , and it is called std::string .

#include <string>

class Person
{
public:
    Person(std::string n, int a) {           
        name = n;
        age = a;
    }

    int age;
    std::string name;

};

int main(int argc, char const *argv[])
{
    Person p("John", 25);
    return 0;
}

Answer 2

Arrays are not assignable. You have to copy elements on each index to the other iteratively. For character arrays, you can use strcpy.

int a[5], b[5];

a = b; // Error

You should specify the size of the array. Use std::string instead of working on character arrays.

Answer 3

There are multiple errors in your code:

1. The type of n is char* : it is not an array but a pointer. You cannot pass built-in arrays as value parameters. You could pass it as a reference, though, eg using char const (&n)[5] (I'll get to the const below).
2. Even if you pass an array name is an array with no elements and actually illegal! You need to use a positive size for an array.

3. Lets assume you declared name as a member of type char name[5]; and n as a reference to an array, you still wouldn't be able to assign these because arrays cannot be assigned. You could, however, copy them using, eg,

    std::copy(std::begin(n), std::end(n), std::begin(name)); 

4. The type of a string literal is char const[N] with N being the number of characters in the string literal. You cannot assign that to char* . In C++03 the assignment was required to be supported but deprecated and in C++11 the assignment isn't allowed anymore (although it is likely that compiler will allow it unless you enable a strict mode).

5. Not an error but a note: you should initialize your members, where possible, in the member initializer list, eg (assuming the member name has a suitable type):

    Person(char const* n, int a) : age(a) { strncpy(this->name, n, sizeof(this->name)); } 

Answer 4

I compile the example code in g++ and what's going on becomes a little clearer:

so.cpp:5:16: error: incompatible types in assignment of ‘char*’ to ‘char [0]’

This zero-length array is a "flexible array member". It must be the last data member of the class, and as with other arrays, you can't assign to it. If you can't use std::string for some reason, such as if your C++ module needs to present a certain API to C modules, try changing the last line of Person as follows:

    const char *name;

This will result in a working program with a const-correctness warning, which can be fixed by changing the first line of the constructor:

    Person(const char n[], int a) {

The final program, which compiles without warnings in g++:

#include <cstdio>
class Person
{
public:
    Person(const char n[], int a) {           
        name = n;
        age = a;
    }

    int age;
    const char *name;

};

int main(int argc, char const *argv[])
{
    Person p("Jack", 14);
    std::puts(p.name);
    return 0;
}

Answer 5

Here is the error I get from g++

$ g++ -Wall example.cc -o example
example.cc: In constructor ‘Person::Person(char*, int)’:
example.cc:5:16: error: incompatible types in assignment of ‘char*’ to ‘char [0]’
example.cc: In function ‘int main(int, const char**)’:
example.cc:16:24: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]

If I substitute char n[] and char name[] with char *n and char *name , you get

$ g++ -Wall example.cc -o example
example.cc: In function ‘int main(int, const char**)’:
example.cc:16:24: warning: deprecated conversion from string constant to ‘char*’ [-Wwrite-strings]

I'm not sure why the compiler likes char* 's better in this case, but it does make more sense to use char* 's when representing strings in general.

Since you are writing in C++, the type std::string is generally preferred since it is more type-safe than char* . This will make code that compiles more robust.

Will all of that in mind, I would write the following code

#include <string>

class Person
{
public:
    Person(std::string n, int a) {           
        name = n;
        age = a;
    }

    int age;
    std::string name;

};

int main(int argc, char const *argv[])
{
    Person p("Jack", 14);
    return 0;
}