Person person = new Person();转为c++

在 C++ 中，创建类实例的语法与 Java 不同。您需要使用关键字 `new` 来动态分配内存并返回指向类实例的指针。因此，将 Java 代码 `Person person = new Person();` 转换为 C++ 代码如下：

Person* person = new Person();

需要注意的是，在 C++ 中，您需要手动管理内存，因此在使用完成后需要使用 `delete` 关键字释放内存。例如：

delete person;

相关问题

struct { char name[20]; int age; }person; person person1= { 0,0 };这样的格式有问题吗

这个格式有问题，因为在给person1赋值时，使用了错误的初始化方式。应该按照结构体定义的顺序，先给name赋值，再给age赋值。

另外，结构体定义应该放在函数外部，以避免重定义错误的问题。

正确的格式应该是这样的：

#include <cstring>

struct Person {
    char name[20];
    int age;
};

Person person1 = {"", 0}; // 或 Person person1 = {0}，可以省略初始化为 0 的元素

int main() {
    // 给 person1 赋值
    std::strcpy(person1.name, "John");
    person1.age = 25;

    return 0;
}

这样就定义了一个名为Person的结构体，包含name和age两个成员变量。同时，person1也被正确地初始化为{name: "", age: 0}。在main函数中，使用了strcpy函数给person1的name赋值为"John"，并给age赋值为25。

class person { public: virtual void a() = 0; }; class common : public person { public: void a() { cout << "Common person buys a ticket." << endl; } }; class student : public person { public: void a() { cout << "Student buys a discounted ticket." << endl; } }; class military : public person { public: void a() { cout << "Military personnel buys a free ticket." << endl; } }; void b(person* p) { p->a(); } int main() { person* p1 = common(); person* p2 = student(); person* p3 = military(); b(p1); b(p2); b(p3); return 0; }将此代码用静态联编实现

静态联编也称为早期绑定，是指在编译期间确定函数的调用对象，通常使用函数重载实现。在此代码中，我们可以使用函数重载实现静态联编。

#include <iostream>
using namespace std;

class person {
public:
    virtual void a() = 0;
};

class common : public person {
public:
    void a() {
        cout << "Common person buys a ticket." << endl;
    }
};

class student : public person {
public:
    void a() {
        cout << "Student buys a discounted ticket." << endl;
    }
};

class military : public person {
public:
    void a() {
        cout << "Military personnel buys a free ticket." << endl;
    }
};

void b(common* c) {
    c->a();
}

void b(student* s) {
    s->a();
}

void b(military* m) {
    m->a();
}

int main() {
    common* c = new common();
    student* s = new student();
    military* m = new military();

    b(c);
    b(s);
    b(m);

    delete c;
    delete s;
    delete m;

    return 0;
}

在静态联编中，我们使用了函数重载，将函数b分别定义为操作common、student和military对象的函数。在main函数中，我们创建了一个common指针指向common对象，一个student指针指向student对象，一个military指针指向military对象，然后分别调用它们的b函数，输出结果与之前使用动态联编的结果相同。

静态联编的缺点是不支持多态，无法在运行时确定函数的调用对象，因此需要在编译期间确定函数的类型。如果需要支持多态，需要使用动态联编。