C++ 形参是类的指针 class * 通过new的方式创建对象

当你在C++中使用类指针（class *）作为函数的形参，并通过 new 关键字创建对象时，这种用法确实会改变类对象的值。原因是你通过指针传递了对象的内存地址，而不是传递对象本身。这意味着在函数内部对对象的任何修改都会直接影响到原始对象。这种做法与值传递和引用传递有明显的区别。

你需要将一个指向类对象的指针传递给函数。这样的做法可以提高代码效率，因为在函数调用过程中不需要复制整个对象。这对于大型对象或者需要动态分配内存的对象尤为有用。

这种用法的优点和区别如下：

1. 避免了拷贝成本：当你传递一个指针时，只需传递一个地址，而不需要拷贝整个对象。这对于大型对象尤其有利，因为它减少了内存消耗和计算时间。

2. 动态内存分配：通过使用 new 关键字分配内存，你可以在运行时动态地创建对象。这使得程序在内存分配方面更加灵活。

3. 修改原始对象：由于你传递的是对象的地址，所以在函数内部对对象所做的任何修改都会影响到原始对象。这在需要修改对象状态的情况下非常有用。

4. 多态性：指针形参可以用于实现多态性。如果你有一个基类的指针，你可以使用它来指向派生类的对象。这使得你可以在运行时根据实际类型调用适当的函数。

与其他形参类型的区别：

1. 值传递：通过值传递，函数接收对象的副本。这意味着在函数内部对对象进行的任何更改都不会影响到原始对象。这种方式在需要保护原始对象不被更改的情况下很有用，但会产生拷贝成本。

2. 引用传递：通过引用传递，函数接收对象的引用。这意味着在函数内部对对象进行的任何更改都会影响到原始对象。引用传递与指针传递类似，但使用起来更加安全，因为引用不能为nullptr，且引用在创建时必须初始化。此外，使用引用的语法通常更简洁。

总之，使用类指针作为形参并通过 new 创建对象，可以实现动态内存分配和直接修改原始对象。这种方法与值传递和引用传递相比，在内存消耗和运行时灵活性方面具有优势。然而，使用指针可能会导致内存泄漏和空指针问题，因此需要谨慎使用。

以下是一个使用指向类对象的指针作为形参的例子：

我们可以通过new关键字创建一个对象并将其地址传递给该指针。

首先，定义一个类：

class MyClass {
public:int x;MyClass(int val) : x(val) {}void display() {std::cout << "The value of x is: " << x << std::endl;}
};

接下来，定义一个函数，该函数接受一个MyClass指针作为参数：

void foo(MyClass *obj) {obj->display();
}

现在，你可以在main函数中使用new关键字创建一个MyClass对象，并将其地址传递给foo函数：

int main() {MyClass *obj = new MyClass(10);foo(obj);// 当你不再需要对象时，记得使用 delete 释放内存delete obj;return 0;
}

在这个例子中，我们首先定义了一个名为MyClass的类。接下来，我们定义了一个名为foo的函数，它接受一个MyClass指针作为参数。在main函数中，我们使用new关键字创建了一个MyClass对象，并将其地址传递给了foo函数。最后，我们使用delete释放了对象占用的内存。

多态性是面向对象编程中的一个重要概念。在C++中，多态性是通过使用基类指针或引用来指向派生类对象实现的。这允许你在运行时根据实际对象类型调用适当的成员函数。多态性有两种主要形式：静态多态性（编译时多态性）和动态多态性（运行时多态性）。

1. 静态多态性：静态多态性是通过模板和函数重载实现的。在编译时，编译器会根据提供的参数类型生成相应的函数。这种多态性的优点是性能较高，因为函数调用在编译时就已经确定。然而，它的缺点是缺乏灵活性，因为所有可能的函数版本都需要在编译时生成。

2. 动态多态性：动态多态性是通过使用虚函数实现的。虚函数允许你在基类中声明一个成员函数，然后在派生类中覆盖该函数。通过使用基类指针或引用来指向派生类对象，你可以在运行时调用适当的函数版本。这种多态性的优点是更高的灵活性，因为函数调用是在运行时确定的。然而，它的缺点是性能较低，因为函数调用需要通过虚函数表（vtable）来查找。

以下是一个简单的C++动态多态性示例：

#include <iostream>// 基类
class Animal {
public:virtual void makeSound() {std::cout << "The animal makes a sound" << std::endl;}
};// 派生类 1
class Dog : public Animal {
public:void makeSound() override {std::cout << "The dog barks" << std::endl;}
};// 派生类 2
class Cat : public Animal {
public:void makeSound() override {std::cout << "The cat meows" << std::endl;}
};void playSound(Animal& animal) {animal.makeSound();
}int main() {Dog dog;Cat cat;playSound(dog);  // 输出：The dog barksplaySound(cat);  // 输出：The cat meowsreturn 0;
}

在这个例子中，Animal 是基类，包含一个虚函数 makeSound()。派生类 Dog 和 Cat 分别覆盖了基类的 makeSound() 函数。playSound() 函数接受一个 Animal 类型的引用参数。当我们分别传递 Dog 和 Cat 对象时，playSound() 函数会根据实际类型调用适当的 makeSound() 函数。

通过使用多态性，你可以更灵活地设计和实现代码，使得程序更容易扩展和维护。