C++中调用类实例的正确方式是什么？新手关于指针调用的疑问

Hey there! Let's break this down for you step by step—no need to feel confused about pointers vs. direct class instances in C++. Both approaches are valid, but they serve different purposes, and you absolutely don't have to use pointers if you don't need to.

First: Calling a Class Instance Without Pointers #

This is the most common and straightforward way to work with class objects, especially for beginners. When you create an object directly (on the stack), memory is managed automatically for you—you don't have to worry about manually freeing it.

Here's a concrete example:

#include <iostream>

class MyClass {
public:
    void greet() {
        std::cout << "Hello from MyClass!" << std::endl;
    }
};

int main() {
    // Create a direct instance of MyClass (stack-allocated)
    MyClass my_instance;
    
    // Use the dot (.) operator to call member functions or access members
    my_instance.greet();

    // No need to delete anything—my_instance is automatically destroyed when main() ends
    return 0;
}

This approach is ideal for most cases where your object only needs to exist within a specific function or scope. It's simpler, safer, and avoids memory leaks by default.

When and How to Use Pointers for Class Instances #

Using pointers to create class instances (allocating on the heap) is useful in specific scenarios, like:

• You need the object to exist beyond the current function/scope
• You're implementing polymorphism (using a base class pointer to point to a derived class object)
• You need to dynamically create objects at runtime (e.g., arrays of objects whose size isn't known at compile time)

Here's how that looks:

#include <iostream>

class MyClass {
public:
    void greet() {
        std::cout << "Hello from MyClass (heap-allocated)!" << std::endl;
    }
};

int main() {
    // Create a pointer to a MyClass instance (heap-allocated)
    MyClass* my_instance_ptr = new MyClass();
    
    // Use the arrow (->) operator to call member functions via the pointer
    my_instance_ptr->greet();

    // IMPORTANT: When using heap allocation, you must manually free the memory
    delete my_instance_ptr;
    // Set the pointer to nullptr to avoid "wild pointer" issues
    my_instance_ptr = nullptr;

    return 0;
}

The key thing to remember here is that new must always be paired with delete to prevent memory leaks. If you forget to delete, the memory will stay allocated until your program exits.

Quick Summary #

• No pointers: Use direct stack-allocated objects for most cases—simple, safe, no manual memory management.
• With pointers: Use heap-allocated objects only when you need the object to outlive its scope, or for advanced patterns like polymorphism.

You weren't wrong to use pointers, but it's totally okay (and often preferred) to skip them when they aren't necessary!

内容的提问来源于stack exchange，提问作者Neolex