如何打印一个类指针的地址

要打印一个类的指针地址，可以使用 `cout` 流和指针运算符 `&`，例如：

#include <iostream>
using namespace std;

class MyClass {
public:
    void print() {
        cout << "Hello, World!" << endl;
    }
};

int main() {
    MyClass* p = new MyClass();
    cout << "The address of p is: " << &p << endl;
    delete p;
    return 0;
}

在上述代码中，我们首先创建了一个 `MyClass` 类的指针 `p`，然后通过 `&` 运算符打印了 `p` 的地址。注意，这里打印的是 `p` 的地址，而不是 `p` 指向的对象的地址。

输出结果类似于：

The address of p is: 0x7fff5fbff928

在实际应用中，打印指针地址可以用于调试和跟踪程序执行过程中内存的使用情况。

相关问题

在一个类中分配一个静态结构体指针，如何对其进行初始化

在一个类中分配一个静态结构体指针，可以在类的定义中进行声明，然后在类的实现中进行初始化。初始化的方式可以有多种，例如使用静态成员初始化、使用构造函数进行初始化等。

以下是一个示例代码：

#include <iostream>

struct MyStruct {
    int x;
    int y;
};

class MyClass {
public:
    static MyStruct* static_struct_ptr;

    MyClass() {
        static_struct_ptr = new MyStruct{1, 2};
    }

    ~MyClass() {
        delete static_struct_ptr;
        static_struct_ptr = nullptr;
    }
};

MyStruct* MyClass::static_struct_ptr = nullptr;

int main() {
    MyClass obj;
    std::cout << "x = " << MyClass::static_struct_ptr->x << ", y = " << MyClass::static_struct_ptr->y << std::endl;
    return 0;
}

在上述代码中，我们定义了一个结构体`MyStruct`，其中包含两个整型成员变量`x`和`y`。然后我们定义了一个类`MyClass`，其中包含一个静态指向`MyStruct`的指针变量`static_struct_ptr`。在`MyClass`的构造函数中，我们使用`new`运算符动态分配一个`MyStruct`类型的空间，并初始化其成员变量的值为1和2，然后将其地址赋值给`static_struct_ptr`；在析构函数中，我们使用`delete`运算符释放`MyStruct`类型的空间。最后，我们在`main()`函数中创建了一个`MyClass`类型的对象`obj`，并打印了`static_struct_ptr`所指向的结构体的成员变量。

注意，在上述代码中，我们需要在类的定义外部进行静态指针变量的定义，使用类名限定静态指针变量的访问。此外，需要注意在程序结束前，需要手动释放动态分配的内存，避免内存泄漏的问题。

编写一个 Employee 类，录入与打印姓名、地址、城市和邮编信息，修改姓名，再次打印信息，并测试观察类对象与指针的内容

好的，以下是 Employee 类的代码实现：

#include <iostream>
#include <string>

using namespace std;

class Employee {
private:
    string name;
    string address;
    string city;
    string postalCode;

public:
    Employee(string name, string address, string city, string postalCode) {
        this->name = name;
        this->address = address;
        this->city = city;
        this->postalCode = postalCode;
    }

    void setName(string name) {
        this->name = name;
    }

    void printInfo() {
        cout << "Name: " << name << endl;
        cout << "Address: " << address << endl;
        cout << "City: " << city << endl;
        cout << "Postal Code: " << postalCode << endl;
    }
};

int main() {
    Employee emp("John Smith", "123 Main St", "New York", "10001");
    emp.printInfo();
    
    emp.setName("Jane Doe");
    emp.printInfo();

    Employee* empPtr = new Employee("Bob Johnson", "456 Elm St", "Los Angeles", "90001");
    empPtr->printInfo();

    empPtr->setName("Alice Williams");
    empPtr->printInfo();

    delete empPtr;

    return 0;
}

在主函数中，我们首先创建了一个 Employee 对象 `emp`，并初始化其姓名、地址、城市和邮编信息。然后调用 `printInfo()` 方法打印信息。

接着，我们调用 `setName()` 方法修改 `emp` 对象的姓名为 "Jane Doe"，再次调用 `printInfo()` 方法打印信息，可以看到姓名已经被修改了。

接下来，我们创建了一个 `Employee*` 类型的指针 `empPtr`，并使用 `new` 运算符动态分配了一个新的 Employee 对象，同时初始化其姓名、地址、城市和邮编信息。然后同样调用 `printInfo()` 方法打印信息。

再次调用 `setName()` 方法修改 `empPtr` 指向的对象的姓名为 "Alice Williams"，并再次调用 `printInfo()` 方法打印信息，可以看到对象的姓名已经被修改了。

最后，我们使用 `delete` 运算符释放了 `empPtr` 指向的对象的内存。

运行程序，输出如下：

Name: John Smith
Address: 123 Main St
City: New York
Postal Code: 10001
Name: Jane Doe
Address: 123 Main St
City: New York
Postal Code: 10001
Name: Bob Johnson
Address: 456 Elm St
City: Los Angeles
Postal Code: 90001
Name: Alice Williams
Address: 456 Elm St
City: Los Angeles
Postal Code: 90001

可以看到，类对象和指针的行为都符合预期。