C++开发基础之函数参数传递的几种类型

一、前言

在C++中，接口指针或类对象的函数参数传递是一个常见的做法，特别是在需要支持多态或动态绑定时。这里将介绍如何传递接口指针或类对象作为函数参数。

二、函数参数传递的几种类型

抽象类（接口）的实例只能通过指针或引用传递，不能作为值传递。具体类的实例可以通过指针、值或引用传递。指针传递和值传递都会创建对象的副本，而引用传递会直接操作原始对象。

示例代码：

#include <iostream>
// 定义一个接口类
class IMyInterface {
public:
    virtual void myMethod() = 0; // 纯虚函数，必须被实现
};
// 定义一个类，它实现了IMyInterface接口
class MyClass : public IMyInterface 
{
public:
    void myMethod() override {
        std::cout << "MyClass::myMethod called" << std::endl;
    }
};
/// <summary>
/// 指针传递：传递抽象类的实例的指针
/// </summary>
/// <param name="interfacePtr"></param>
void doSomething1(IMyInterface* interfacePtr) {
    interfacePtr->myMethod();
}

/// <summary>
/// 错误用法，不允许使用抽象类类型作为函数参数，也就是说不能实例化。
/// </summary>
/// <param name="interfacePtr"></param>
//void doSomething2(IMyInterface interfacePtr) {
//    interfacePtr.myMethod();
//}

/// <summary>
/// 引用传递 需要传递抽象类的实例对象的引用.
/// </summary>
/// <param name="interfacePtr"></param>
void doSomething3(IMyInterface &interfacePtr) {
    interfacePtr.myMethod();
}

/// <summary>
/// 对象的指针传递
/// </summary>
/// <param name="pMyCalss"></param>
void doSomething4(MyClass* pMyCalss) {
    pMyCalss->myMethod();
}

/// <summary>
/// 值传递：会创建myObj的副本
/// </summary>
/// <param name="myObj"></param>
void doSomething5(MyClass myObj) {
    myObj.myMethod();
}

/// <summary>
/// 引用传递：直接操作原始对象
/// </summary>
/// <param name="myObj"></param>
void doSomething6(MyClass &myObj) {
    myObj.myMethod();
}

int main() {
    MyClass obj;
    IMyInterface* pMyInterface = &obj;
    doSomething1(pMyInterface);
    //doSomething2(obj); 错误用法
    doSomething3(*pMyInterface);

    doSomething4(&obj); 
    doSomething5(obj); 
    doSomething6(obj);
    return 0;
}

1.抽象类（接口）的实例的指针传递

/// <summary>
/// 指针传递：传递抽象类的实例的指针
/// </summary>
/// <param name="interfacePtr"></param>
void doSomething1(IMyInterface* interfacePtr) {
    interfacePtr->myMethod();
}

int main() {
    MyClass obj;
    IMyInterface* pMyInterface = &obj;
    doSomething1(&obj);
    doSomething1(pMyInterface);
    return 0;
} 

将抽象类指针作为函数参数传递。这允许函数接受任何实现了抽象类接口的类的实例。

2.抽象类（接口）的实例值传递（错误用法）

/// <summary>
/// 编译时错误，抽象类不能被实例化，不允许使用抽象类类型作为函数参数，也就是说不能实例化。
/// </summary>
/// <param name="interfacePtr"></param>
//void doSomething2(IMyInterface interfacePtr) {
//    interfacePtr.myMethod();
//}

抽象类不能被实例化，因此不能作为值传递给函数。

3.抽象类（接口）的实例的对象的引用传递

/// <summary>
/// 引用传递 需要传递抽象类的实例对象的引用.
/// </summary>
/// <param name="interfacePtr"></param>
void doSomething3(IMyInterface &interfacePtr) {
    interfacePtr.myMethod();
}

int main() {
    MyClass obj;
    IMyInterface* pMyInterface = &obj;
    doSomething3(*pMyInterface);
    return 0;
}

将抽象类对象的引用作为函数参数传递。这允许函数直接访问和修改原始对象。

4.实例对象的指针传递

/// <summary>
/// 对象的指针传递
/// </summary>
/// <param name="pMyCalss"></param>
void doSomething4(MyClass* pMyCalss) {
    pMyCalss->myMethod();
}

int main() {
    MyClass obj;
    IMyInterface* pMyInterface = &obj;
    doSomething4(&obj); 
    return 0;
}

将具体类对象的指针作为函数参数传递。这允许函数接受任何实现了抽象类接口的类的实例。

5.实例对象的值传递

/// <summary>
/// 值传递：会创建myObj的副本
/// </summary>
/// <param name="myObj"></param>
void doSomething5(MyClass myObj) {
    myObj.myMethod();
}
int main() {
    MyClass obj;
    doSomething5(obj); 
    return 0;
}

将具体类对象作为值传递给函数。这创建了一个对象的副本，因此函数内部对对象的修改不会影响原始对象。

6.实例对象的引用传递

/// <summary>
/// 引用传递：直接操作原始对象
/// </summary>
/// <param name="myObj"></param>
void doSomething6(MyClass &myObj) {
    myObj.myMethod();
}

int main() {
    MyClass obj;
    doSomething6(obj);
    return 0;
}

将具体类对象的引用作为函数参数传递。这允许函数直接访问和修改原始对象。

三、注意事项

• 当传递接口指针时，确保指针指向的对象确实实现了该接口。
• 当传递类对象时，确保对象的状态不会因为函数的调用而受到影响，除非函数是类的成员函数。
• 引用参数可以避免拷贝对象，提高效率。
• 指针参数可以接受空指针，引用参数不能接受空引用。
• 通过接口指针或类对象的传递，可以编写出更加灵活和可扩展的代码。