C++类定义通过class关键字声明成员变量和函数，并用private、public、protected控制访问权限：private成员仅类内和友元可访问，public成员对外公开，protected成员允许派生类访问；成员函数在类内定义默认为inline，类外定义需显式声明inline；友元函数或类可突破封装访问私有成员，常用于运算符重载或性能优化，但应谨慎使用以维护封装性。
C++类定义的核心在于声明类的成员变量和成员函数，并控制对它们的访问权限。访问控制权限决定了类的外部（以及派生类）如何访问这些成员。
解决方案
C++中使用
class关键字定义类。一个基本的类定义如下：
class MyClass {
private:
// 私有成员变量和函数
public:
// 公有成员变量和函数
protected:
// 保护成员变量和函数
};class MyClass
：声明了一个名为MyClass
的类。private
：指定私有访问权限。私有成员只能由类的成员函数和友元函数访问。public
：指定公有访问权限。公有成员可以被类的任何部分访问，包括外部代码。protected
：指定保护访问权限。保护成员可以被类的成员函数、友元函数以及派生类的成员函数访问。
具体示例
立即学习“C++免费学习笔记（深入）”；
#include <iostream>
class Dog {
private:
std::string name; // 狗的名字，私有成员
int age; // 狗的年龄，私有成员
protected:
void bark() { // 叫的方法，保护成员
std::cout << "Woof!" << std::endl;
}
public:
Dog(std::string n, int a) : name(n), age(a) {} // 构造函数
void displayInfo() { // 显示信息的方法，公有成员
std::cout << "Name: " << name << ", Age: " << age << std::endl;
}
void celebrateBirthday() { //庆祝生日
age++;
std::cout << "Happy birthday, " << name << "! Now " << age << " years old." << std::endl;
}
};
class GuardDog : public Dog {
public:
GuardDog(std::string n, int a) : Dog(n, a) {}
void guard() {
std::cout << "GuardDog is guarding..." << std::endl;
bark(); // 可以访问基类的protected成员
}
};
int main() {
Dog myDog("Buddy", 3);
myDog.displayInfo(); // 可以访问公有成员
myDog.celebrateBirthday();
GuardDog myGuardDog("Rocky", 5);
myGuardDog.guard();
// myDog.name = "NewName"; // 错误：无法访问私有成员
return 0;
}为什么需要访问控制权限？
访问控制权限是面向对象编程中的一个关键概念，它封装性。封装性隐藏了类的内部实现细节，只暴露必要的接口给外部使用。这有几个好处：
-
防止意外修改： 阻止外部代码直接修改类的内部状态，确保数据的一致性和有效性。例如，如果
Dog
类的age
成员是公有的，外部代码可能将其设置为负数，这显然是不合理的。 - 简化维护： 当类的内部实现发生变化时，只要公有接口保持不变，外部代码就不需要修改。
- 提高代码可读性： 通过明确哪些成员是公有的，哪些是私有的，可以更容易地理解类的设计意图。
成员函数在类定义内还是类定义外定义有什么区别？
在类定义内定义的成员函数会被编译器默认为
inline函数，这通常适用于函数体比较小的函数。内联函数可以减少函数调用的开销，提高程序的执行效率。在类定义外定义的成员函数则不会默认是内联的，但可以使用
inline关键字显式声明为内联函数。
例如：
class MyClass {
public:
void inlineFunc() { // 在类内定义，默认inline
std::cout << "Inline function" << std::endl;
}
void nonInlineFunc(); // 在类内声明，在类外定义
};
inline void MyClass::nonInlineFunc() { // 显式声明为inline
std::cout << "Non-inline function" << std::endl;
}选择在哪定义成员函数通常取决于函数的复杂度和性能需求。简单的函数适合在类内定义，而复杂的函数适合在类外定义，以提高代码的可读性。
友元函数和友元类是什么？它们有什么作用？
友元函数和友元类允许外部函数或类访问类的私有和保护成员。友元关系是一种特权关系，打破了类的封装性，因此应该谨慎使用。
友元函数示例：
#include <iostream>
class Box {
private:
double width;
public:
Box(double w) : width(w) {}
friend void printWidth(Box box); // 声明友元函数
};
void printWidth(Box box) {
// 友元函数可以访问Box类的私有成员
std::cout << "Width of box : " << box.width << std::endl;
}
int main() {
Box box(10.0);
printWidth(box);
return 0;
}友元类示例：
#include <iostream>
class A {
private:
int x;
public:
A(int val) : x(val) {}
friend class B; // B是A的友元类
};
class B {
public:
void display(A a) {
std::cout << "Value of A::x is " << a.x << std::endl; // 可以访问A的私有成员
}
};
int main() {
A a(5);
B b;
b.display(a);
return 0;
}友元函数和友元类通常用于以下情况：
- 运算符重载： 当需要重载运算符，并且运算符的操作数需要访问类的私有成员时。
- 高效的数据访问： 在某些性能关键的代码中，为了避免通过公有接口访问数据的开销，可以使用友元关系。
- 类之间的协作： 当两个类需要紧密协作，并且一个类需要访问另一个类的内部状态时。
但是，过度使用友元关系会破坏类的封装性，降低代码的可维护性，所以要谨慎使用。
