1、成员函数(方法)声明

成员函数可以定义在类定义内部，或者单独使用范围解析运算符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。

例如，

#include<iostream> 
using namespace std;
#include <string>
class Foo {
public:
    std::string s;
    // 默认构造函数
    Foo() { std::cout << "default constructor" 
    << std::endl; }
    // 复制构造函数
    Foo(const Foo& foo) { std::cout << "copy constructor" 
    << std::endl; s = foo.s; }
    // 复制赋值运算符
    Foo& operator=(const Foo& foo) { std::cout 
    << "copy assignment operator" <<
    std::endl; s = foo.s; return * this;}
    // 移动构造函数
    Foo(Foo&& foo) { std::cout << "move constructor" 
    << std::endl; s = std::move(foo.s); }
    // 移动赋值运算符
    Foo& operator=(Foo&& foo) { std::cout 
    << "move assignment operator" 
    << std::endl; s = std::move(foo.s); return *this;}
};
int main() {
    Foo foo1;
    Foo foo2(foo1);
    foo1 = foo2;
    Foo foo3(std::move(foo1));
    foo2 = std::move(foo3);
}

2）类外部定义（通常用于函数较长时）

#include <iostream>
using namespace std;

class MyClass {
public:
    int x;

    // 构造函数
    MyClass(int val);

    // 成员函数声明
    void printValue();
    int getValue();
};

// 类外部成员函数定义
MyClass::MyClass(int val) : x(val) {}

void MyClass::printValue() {
    cout << "Value of x: " << x << endl;
}

int MyClass::getValue() {
    return x;
}

int main() {
    MyClass obj(10);
    obj.printValue();  // 输出 Value of x: 10
    cout << obj.getValue() << endl;  // 输出 10
    return 0;
}

2、使用范围解析运算符(::)

可以在类的外部使用范围解析运算符 :: 定义函数。

例如，

#include <iostream>
#include<cstring>
using namespace std;
class Person
{
    string name;
    int age;
    char sex;
// 成员函数声明
public:
    void Register(string,int,char);
    void ShowMe();
    void Input();
    string ID;
};
// 成员函数定义
void Person::Register(string na,int ag,char se)
{
    name=na;
    age=ag;
    sex=se;
}
void Person::ShowMe()
{
    cout<<name<<" "<<age<<" "<<sex<<endl;
}
void Person::Input()
{
    cin>>name>>age>>sex;
 } 
int main()
{
    Person person1,person2;
    person1.Input();
    person2.Register("cjavapy",19,'m');
    person1.ShowMe();
    person2.ShowMe();
    return 0;
}

3、类成员函数的访问控制

成员函数可以访问类的私有（private）和保护（protected）成员。通常使用 public 访问控制符将成员函数暴露给外部使用，private 或 protected 用于限制对外访问。

#include <iostream>
using namespace std;

class MyClass {
private:
    int privateValue;
public:
    int publicValue;

    MyClass(int val1, int val2) : privateValue(val1), 
    publicValue(val2) {}

    void setPrivateValue(int val) { privateValue = val; }
    void printValues() const { cout << "Private: " << 
    privateValue << ", Public: " << publicValue << endl; }

protected:
    int protectedValue;
};

class DerivedClass : public MyClass {
public:
    DerivedClass(int val1, int val2) : MyClass(val1, val2) {}

    void setProtectedValue(int val) { protectedValue = val; }
    void printProtectedValue() const { cout << "Protected: "
    << protectedValue << endl; }
};

int main() {
    MyClass obj1(10, 20);
    obj1.printValues();
    obj1.setPrivateValue(30);
    obj1.printValues();

    DerivedClass obj2(100, 200);
    obj2.setProtectedValue(300);
    obj2.printProtectedValue();

    return 0;
}

4、常成员函数（const member functions）

常成员函数是指不会修改类的成员变量的函数，可以在常量对象上调用。

#include <iostream>
using namespace std;

class MyClass {
public:
    int x;

    MyClass(int val) : x(val) {}

    // 常成员函数
    void printValue() const {
        cout << "Value of x: " << x << endl;
    }
};

int main() {
    // 创建对象并初始化
    MyClass obj(10);

    // 调用常成员函数
    obj.printValue();  // 输出 Value of x: 10

    // 访问公有成员变量
    cout << "x is: " << obj.x << endl;  // 输出 x is: 10

    return 0;
}

5、静态成员函数（static member functions）

静态成员函数属于类本身，而不是类的实例，因此它不能访问非静态成员。静态成员函数只能访问静态成员变量和其他静态成员函数。

#include <iostream>
using namespace std;

class MyClass {
public:// 静态成员变量，记录对象数量
    static int count;  

    MyClass() {
        count++;  // 每创建一个对象，count增加
    }

    static void printCount() {
        cout << "Count: " << count << endl;  // 打印当前对象数量
    }
};

int MyClass::count = 0;  // 静态成员变量初始化

int main() {
    MyClass obj1;  // 创建第一个对象，count变为1
    MyClass obj2;  // 创建第二个对象，count变为2
    MyClass obj3;  // 创建第三个对象，count变为3
    // 输出 Count: 3，打印当前对象数量
    MyClass::printCount();  

    return 0;
}