C++ 中的方法与函数示例

函数

函数是执行特定任务的代码块，其可重复使用，但并不返回任何值。函数定义后，可通过程序中其他地方调用它。

以下是 C++ 中函数定义的基本格式：

return_type function_name( parameter list ) {
   // 函数体
}

其中，return_type 表示函数返回值的数据类型，function_name 为函数名字，参数列表指定了函数的参数。函数体包含代码块，这些代码执行指定的任务。

示例：

// 一个简单的 C++ 函数
#include<iostream>
using namespace std;
void printHello(){
    cout<<"Hello World!"<<endl;
}
int main(){
    // 调用函数
    printHello();
    return 0;
}

输出：

Hello World!

方法

方法是面向对象编程 (OOP) 的一个重要概念，是一种通过在对象上执行操作来完成任务的代码块。方法由类定义，类是一个包含变量和方法的蓝图。类中定义的方法通过对象调用，并允许访问该对象的数据。

以下是 C++ 中方法定义的基本格式：

class class_name {
   public:
      return_type method_name( parameter list );
      ...
};

其中，class_name 表示类名，method_name 是方法名，参数列表指定了方法的参数。方法还可以定义为公有或私有的，以指定是否可以从其他对象访问该方法。

示例：

// 一个简单的 C++ 类
#include<iostream>
using namespace std;
class MyClass {
    public:
      // 公有方法
      int myMethod(int a, int b){
         return a + b;
      }
};
int main(){
    // 创建 MyClass 对象
    MyClass myObj;
    // 调用公有方法
    cout << myObj.myMethod(1, 2)<<endl;
    return 0;
}

输出：

3

静态方法

静态方法是属于类而不是对象的方法，这意味着无需创建类的新实例即可调用该方法。

以下是 C++ 中静态方法定义的基本格式：

class class_name {
   public:
      static return_type method_name( parameter list );
      ...
};

其中，static 关键字用于标识该方法为静态方法。

示例：

// 一个简单的 C++ 静态方法
#include<iostream>
using namespace std;
class MyClass {
    public:
      static void myStaticMethod() {
         cout<< "Static Method."<<endl;
      }
      void myMethod(){
          cout<< "Normal Method."<<endl;
      }
};
int main(){
    // 调用静态方法
    MyClass::myStaticMethod();
    // 调用普通方法
    MyClass obj;
    obj.myMethod();
    return 0;
}

输出：

Static Method.
Normal Method.

成员方法

成员方法是属于对象的方法，可以访问该对象的数据。

以下是 C++ 中成员方法定义的基本格式：

class class_name {
   public:
      return_type method_name( parameter list );
      ...
};

其中，public 关键字用于标记该方法为公有方法。

示例：

// 一个简单的 C++ 类
#include<iostream>
using namespace std;
class MyClass {
    private:
      int myVar;
    public:
      void setVar(int a) {
          myVar = a;
      }
      int getVar() {
         return myVar;
      }
};
int main(){
    // 创建 MyClass 对象
    MyClass myObj;
    // 设置值
    myObj.setVar(42);
    // 输出值
    cout << myObj.getVar()<<endl;
    return 0;
}

输出：

42

静态成员方法

静态成员方法是属于类而不是对象的方法，可以访问类的静态成员变量。

以下是 C++ 中静态成员方法定义的基本格式：

class class_name {
   public:
      static return_type method_name( parameter list );
      ...
};

示例：

// 一个简单的 C++ 静态成员方法
#include<iostream>
using namespace std;
class MyClass {
    private:
      static int myVar;
    public:
      static int getVar(){
          return myVar;
      }
      static void setVar(int a){
          myVar = a;
      }
};
int MyClass::myVar = 42;
int main(){
    // 输出初始值
    cout<<MyClass::getVar()<<endl;
    // 修改静态变量的值
    MyClass::setVar(100);
    // 输出修改后的值
    cout<<MyClass::getVar()<<endl;
    return 0;
}

输出：

42
100

构造函数

构造函数是类的一个特殊方法，用于在创建对象时初始化对象的数据。

以下是 C++ 中构造函数定义的基本格式：

class class_name {
   public:
      class_name( parameter list ) {
         // 构造函数代码
      }
};

示例：

// 一个简单的 C++ 构造函数
#include<iostream>
using namespace std;
class MyClass {
    public:
      int myVar;
      // 构造函数
      MyClass(){
          myVar = 42;
      }
};
int main(){
    // 创建 MyClass 对象
    MyClass myObj;
    // 输出对象的变量值
    cout<<myObj.myVar<<endl;
    return 0;
}

输出：

42

带参数的构造函数

可以在创建对象时向构造函数传递参数，以初始化对象的数据。

以下是 C++ 中带参数的构造函数定义的基本格式：

class class_name {
   public:
      class_name( parameter list ) {
         // 构造函数代码
      }
};

示例：

// 一个简单的 C++ 带参数的构造函数
#include<iostream>
using namespace std;
class MyClass {
    public:
      int myVar;
      // 带参数的构造函数
      MyClass(int a){
          myVar = a;
      }
};
int main(){
    // 创建 MyClass 对象，并传递参数
    MyClass myObj(42);
    // 输出对象的变量值
    cout<<myObj.myVar<<endl;
    return 0;
}

输出：

42

析构函数

析构函数是在销毁对象时调用的特殊函数，用于释放对象分配的资源。

以下是 C++ 中析构函数定义的基本格式：

class class_name {
   public:
      ~class_name() {
         // 析构函数代码
      }
};

示例：

// 一个简单的 C++ 析构函数
#include<iostream>
using namespace std;
class MyClass {
    public:
      // 构造函数
      MyClass(){
          cout<<"Constructor"<<endl;
      }
      // 析构函数
      ~MyClass(){
          cout<<"Destructor"<<endl;
      }
};
int main(){
    // 创建 MyClass 对象
    MyClass myObj;
    return 0;
}

输出：

Constructor
Destructor