调用类成员通常有以下几种方式：
通过类的对象调用成员
```cpp
class MyClass {
public:
void myFunction（） {
std::cout << "Hello from MyClass!" << std::endl；
}
}；
int main（） {
MyClass myObject；
myObject.myFunction（）； // 调用MyClass类的myFunction函数
return 0；
}
```
通过类的静态成员调用
```cpp
class MyClass {
public:
static void myStaticFunction（） {
std::cout << "Hello from MyClass's static function!" << std::endl；
}
}；
int main（） {
MyClass::myStaticFunction（）； // 调用MyClass类的静态函数
return 0；
}
```
通过类的父类对象调用子类成员（如果适用）：
```cpp
class ParentClass {
public:
void parentFunction（） {
std::cout << "Parent class function." << std::endl；
}
}；
class ChildClass : public ParentClass {
public:
void childFunction（） {
std::cout << "Child class function." << std::endl；
}
}；
int main（） {
ChildClass childObject；
ParentClass* parentObject = &childObject；
parentObject->parentFunction（）； // 通过父类对象调用子类继承的父类成员函数
childObject.childFunction（）； // 直接通过子类对象调用子类成员函数
return 0；
}
```
通过作用域解析运算符（::）调用类成员（如果适用）：
```cpp
class OuterClass {
public:
class InnerClass {
public:
void innerFunction（） {
std::cout << "Inner class function." << std::endl；
}
}；
}；
int main（） {
OuterClass::InnerClass innerObject；
innerObject.innerFunction（）； // 通过作用域解析运算符调用内部类成员函数
return 0；
}
```
通过友元函数调用私有成员（如果适用）：
```cpp
class Test {
private:
static void fun1（） {
std::cout << "fun1 called." << std::endl；
}
friend void fun2（）； // fun2（）设为类Test的友元函数
}；
void fun2（） {
Test::fun1（）； // 友元函数调用Test类的私有静态成员函数
}
int main（） {
fun2（）；
return 0；
}
```
以上是调用类成员的基本方法。请根据您的具体需求选择合适的方式