通讯员队伍建设与网站新闻管理关键词点击工具
1. 类和对象的基本概念
- 类：用户自定义的数据类型，包含数据成员（属性）和成员函数（方法）。
- 对象：类的实例，占用内存空间，具有类中定义的属性和方法。
示例：
class Dog { // 定义类
public:std::string name; // 属性int age;void bark() { // 方法std::cout << name << " says: Woof!" << std::endl;}
};int main() {Dog myDog; // 创建对象myDog.name = "Buddy";myDog.age = 3;myDog.bark(); // 输出：Buddy says: Woof!return 0;
}2. 访问限定符
- public：类外可直接访问。
- private：仅类内和友元可访问（默认访问权限）。
- protected：类内、派生类和友元可访问。
示例：
class Student {
private:int score; // 私有成员，外部不可访问public:std::string name;void setScore(int s) { score = s; } // 通过公有方法修改私有成员
};int main() {Student stu;stu.name = "Alice";stu.setScore(90);// stu.score = 85; // 错误：score是private成员return 0;
}3. 面向对象的三大特征
3.1 封装
将数据和操作数据的方法绑定，隐藏实现细节。
3.2 继承
允许新类继承现有类的成员，实现代码复用。
class Animal {
public:void eat() { std::cout << "Eating..." << std::endl; }
};class Cat : public Animal { // 继承Animal
public:void meow() { std::cout << "Meow!" << std::endl; }
};int main() {Cat cat;cat.eat(); // 继承自Animalcat.meow(); // 自身方法return 0;
}3.3 多态
通过虚函数实现运行时绑定（需继承和虚函数支持）。
class Shape {
public:virtual void draw() { std::cout << "Drawing a shape" << std::endl; } // 虚函数
};class Circle : public Shape {
public:void draw() override { std::cout << "Drawing a circle" << std::endl; } // 重写虚函数
};int main() {Shape* shape = new Circle();shape->draw(); // 输出：Drawing a circle（多态）delete shape;return 0;
}4. 对象存储方式
- 栈内存：对象在栈上分配，生命周期随作用域结束自动销毁。
- 堆内存：对象通过
new在堆上分配，需手动delete释放。 - 对象的存储方式设计：对象存储方式的设计：只保存成员变量，成员函数放在公共的代码段里，编译链接是就会根据函数名去公共代码区找到函数的地址，然后Call函数地址
5. this指针
指向当前对象的指针，用于区分成员变量与局部变量。
示例：
class Box {
private:int width;
public:void setWidth(int width) {this->width = width; // this访问成员变量}
};6. 构造函数与析构函数
6.1 构造函数
- 初始化对象，与类同名，无返回类型。
- 默认构造函数：无参或所有参数有默认值。
- 带参数的构造函数：初始化对象时传入参数。
6.2 析构函数
- 对象销毁时自动调用，用于释放资源。
- 名称：
~ClassName()，无参数。
示例：
class Book {
public:std::string title;Book() { title = "Unknown"; } // 默认构造函数Book(const std::string& t) : title(t) {} // 带参数的构造函数~Book() { std::cout << title << " destroyed" << std::endl; } // 析构函数
};int main() {Book book1; // 调用默认构造Book book2("C++ Primer"); // 调用带参构造return 0; // 析构函数自动调用
}7. 拷贝构造函数
- 用于通过同类型对象初始化新对象。
- 默认浅拷贝，需自定义深拷贝（如涉及指针）。
示例：
class Array {
private:int* data;int size;
public:Array(int s) : size(s) { data = new int[s]; } // 构造函数Array(const Array& other) : size(other.size) { // 拷贝构造（深拷贝）data = new int[size];memcpy(data, other.data, size * sizeof(int));}~Array() { delete[] data; } // 析构函数释放内存
};8. 运算符重载
允许自定义运算符对类对象的操作。
示例（重载+运算符）：
class Vector {
public:int x, y;Vector(int x, int y) : x(x), y(y) {}Vector operator+(const Vector& other) { // 重载+return Vector(x + other.x, y + other.y);}
};int main() {Vector v1(1, 2), v2(3, 4);Vector v3 = v1 + v2; // 调用重载的+return 0;
}9. 默认成员函数
编译器自动生成的函数（若未显式定义）：
- 默认构造函数（若无其他构造函数）。
- 默认析构函数。
- 默认拷贝构造函数（浅拷贝）。
- 默认赋值运算符（浅拷贝）。
- 移动构造运算符。
- 移动赋值运算符。
10. const成员
- const成员函数：不能修改成员变量。
- const对象：只能调用const成员函数。
示例：
class Counter {
private:mutable int count; // mutable成员可在const函数中修改
public:Counter() : count(0) {}void increment() { count++; }int getCount() const { return count; } // const成员函数
};int main() {const Counter c;// c.increment(); // 错误：const对象不能调用非const函数int cnt = c.getCount(); // 允许调用const函数return 0;
}11. static成员
- static成员变量：所有对象共享，类外初始化。
- static成员函数：只能访问static成员，无
this指针。
示例：
class Player {
public:static int playerCount; // 静态成员变量声明Player() { playerCount++; }static void showCount() { std::cout << playerCount << std::endl; } // 静态函数
};
int Player::playerCount = 0; // 类外初始化int main() {Player p1, p2;Player::showCount(); // 输出：2return 0;
}12. 友元
- 友元函数/类：允许访问类的私有成员。
- 破坏封装性，慎用。
示例：
class Box {
private:int width;friend void printWidth(Box box); // 友元函数声明
};void printWidth(Box box) {std::cout << box.width << std::endl; // 访问私有成员
}int main() {Box b;printWidth(b);return 0;
}13. 初始化列表
在构造函数中初始化成员变量（效率更高，必须用于const成员）。
示例：
class Student {
private:const int id; // const成员必须用初始化列表std::string name;
public:Student(int i, const std::string& n) : id(i), name(n) {}
};14. 匿名对象
没有名字的临时对象，生命周期仅限当前行。
示例：
class Logger {
public:Logger() { std::cout << "Logger created" << std::endl; }~Logger() { std::cout << "Logger destroyed" << std::endl; }
};int main() {Logger(); // 创建匿名对象，立即析构return 0;
}
// 输出：
// Logger created
// Logger destroyed15. 内部类
定义在类内部的类，可访问外部类的静态成员。
示例：
class Outer {
private:static int value; // 外部类静态成员
public:class Inner { // 内部类public:void print() {std::cout << "Outer::value = " << value << std::endl; // 访问外部类静态成员}};
};
int Outer::value = 100;int main() {Outer::Inner inner;inner.print(); // 输出：Outer::value = 100return 0;
}16. new/malloc 与 delete/free 对比
| 特性 | new/delete | malloc/free |
|---|---|---|
| 类型安全 | 是（自动计算大小） | 否（需手动计算大小） |
| 调用构造/析构 | 是 | 否 |
| 内存来源 | 自由存储区（可能是堆） | 堆 |
| 失败处理 | 抛出bad_alloc异常 | 返回NULL |
| 重载 | 可重载operator new/delete | 不可重载 |
示例：
int main() {int* p1 = new int(10); // 调用构造函数delete p1; // 调用析构函数int* p2 = (int*)malloc(sizeof(int)); // 无构造free(p2); // 无析构// 混用会导致未定义行为// int* p3 = new int;// free(p3); // 错误！return 0;
}16. 思维导图
(网课版本可通过右键图片在心标签页中打开然后方大网页观看，也可保存到本地查看）
