C++ 类和对象
C++是一种支持面向对象编程的高级编程语言，类和对象是C++中面向对象编程的基本概念。
类是一种用户自定义的数据类型，它可以包含属性和方法。在类中定义的属性称为成员变量，可以存储对象的状态；而方法称为成员函数，可以操作这些成员变量或实现其他功能。类通过封装数据和行为，提供了一种有效的编程方式，可以将复杂的问题简化为一组简单的对象和相应的方法。
对象是类的具体实例，它可以调用类中定义的成员函数和访问成员变量。每个对象都有其自身的状态和行为，通过创建不同的对象来完成不同的任务。
下面是一个简单的C++类的示例：
```cpp
class Person {
public:
string name;
int age;
void sayHello() {
cout << "Hello, my name is " << name << ", and I'm " << age << " years old." << endl;
}
};
```
在这个示例中，我们定义了一个名为Person的类，它包含两个公共成员变量name和age，以及一个公共成员函数sayHello。其中，公共成员变量可以被外部类的对象访问和修改，公共成员函数可以被外部类的对象调用。
要使用这个类，需要先创建该类的对象。例如：
```cpp
Person person1;
person1.name = "Alice";
person1.age = 18;
person1.sayHello();
```
这里我们创建了一个名为person1的Person对象，并给它的成员变量name和age分别赋值。然后，我们调用sayHello函数，输出该对象的信息。
总之，类和对象是C++中面向对象编程的基本概念，通过封装数据和行为，提供了一种有效的编程方式，可以将复杂的问题简化为一组简单的对象和相应的方法。除了成员变量和成员函数外，C++中的类还可以有构造函数和析构函数。构造函数是一种特殊的成员函数，它在创建对象时被调用，负责初始化对象的成员变量；而析构函数则在对象被销毁时自动调用，用于清理对象所占用的资源。
下面是一个带有构造函数和析构函数的Person类示例：
```cpp
class Person {
public:
string name;
int age;
Person(string n, int a) { // 构造函数
name = n;
age = a;
cout << "A person named " << name << " is created." << endl;
}
~Person() { // 析构函数
cout << "A person named " << name << " is destroyed." << endl;
}
void sayHello() {
cout << "Hello, my name is " << name << ", and I'm " << age << " years old." << endl;
}
};
```
在这个示例中，我们在类定义中添加了一个构造函数和一个析构函数，分别完成对象的初始化和清理工作。构造函数的名称与类名称相同，没有返回类型，可以带有参数。析构函数的名称也与类名称相同，但在前面加上一个波浪号"~"，也没有返回类型，不带参数。
要使用这个类，可以像这样创建对象：
```cpp
Person person1("Alice", 18);
person1.sayHello();
```
在创建对象时，会自动调用构造函数，完成对象的初始化；而在对象被销毁时，会自动调用析构函数，完成清理工作。
总之，C++中的类和对象是面向对象编程的基本概念，通过封装数据和行为，提供了一种有效的编程方式。除了成员变量和成员函数外，类还可以有构造函数和析构函数，分别用于对象的初始化和清理工作。在C++中，类还有一些其他的特性，例如：
- 可见性控制：类的成员可以被限定为公共(public)、私有(private)或受保护(protected)，以实现封装和数据隐藏。公共成员可以被任何对象访问和修改，私有成员只能被同类对象访问和修改，受保护成员可以被同类对象和派生类对象访问和修改。
- 继承：子类可以从父类继承属性和方法，并且可以添加自己的属性和方法。继承可以提高代码重用性和可维护性，也是实现多态(polymorphism)和抽象(abstraction)的基础。
- 多态：同一个函数可以根据不同的调用方式产生不同的行为，这种现象称为多态。C++中，多态可以通过虚函数(virtual function)和纯虚函数(pure virtual function)来实现。
下面是一个带有继承和多态的Person类示例：
```cpp
class Student : public Person { // 继承自Person类
public:
string school;
Student(string n, int a, string s) : Person(n, a) { // 调用父类构造函数
school = s;
cout << "A student named " << name << " is created." << endl;
}
void sayHello() { // 重载父类函数
cout << "Hello, my name is " << name << ", and I'm a student from " << school << "." << endl;
}
};
void introduce(Person& p) { // 多态函数
p.sayHello(); // 调用虚函数实现多态
}
int main() {
Person person1("Alice", 18);
Student student1("Bob", 20, "Harvard");
introduce(person1);
introduce(student1);
return 0;
}
```
在这个示例中，我们定义了一个名为Student的子类，继承自Person父类。在子类中，我们添加了一个新的成员变量school，并重载了父类的sayHello函数，以实现不同的行为。
在main函数中，我们分别创建了一个Person对象和一个Student对象，并通过多态函数introduce来演示多态调用的效果。由于p.sayHello是虚函数，因此可以根据不同的参数类型产生不同的行为，实现多态效果。
总之，C++中的类还有许多其他特性，如可见性控制、继承和多态等，这些特性为面向对象编程提供了更加强大的功能和灵活性。熟练掌握这些特性，可以帮助程序员更加高效地开发出可靠、可维护的软件系统。另外，C++中的类还可以有静态成员和常量成员。静态成员是与类相关联的成员变量或成员函数，它们不属于任何对象，而是属于整个类。常量成员是在定义时被初始化的常量，它们不能被修改。
下面是一个带有静态成员和常量成员的Person类示例：
```cpp
class Person {
public:
static int count; // 静态成员，记录创建的对象数
const string type = "human"; // 常量成员，类型为人类
string name;
int age;
Person(string n, int a) {
name = n;
age = a;
count++; // 每次创建对象时增加计数器
cout << "A person named " << name << " is created. Now there are " << count << " persons." << endl;
}
~Person() {
count--; // 每次销毁对象时减少计数器
cout << "A person named " << name << " is destroyed. Now there are " << count << " persons." << endl;
}
void sayHello() {
cout << "Hello, my name is " << name << ", and I'm " << age << " years old." << endl;
}
};
int Person::count = 0; // 静态成员需要在类外进行初始化
int main() {
Person person1("Alice", 18);
Person person2("Bob", 20);
cout << person1.type << endl;
return 0;
}
```
在这个示例中，我们定义了一个静态成员count，用于记录创建的Person对象数。同时，我们添加了一个常量成员type，表示该类对象的类型。
在main函数中，我们创建了两个Person对象，并输出了第一个对象的类型。由于type是常量成员，所以它不能被修改。
总之，C++中的类还可以有静态成员和常量成员，它们分别与整个类和单个对象相关联，为程序员提供了更加灵活的编程方式。熟练掌握这些特性，可以帮助程序员写出更加高效、可靠的代码。C++中的类还有一些高级特性，例如模板和友元。
模板(template)是一种通用的编程技术，可以将数据类型参数化，以实现代码重用和泛型编程。C++中的模板可以用于函数模板和类模板两种形式。
下面是一个简单的函数模板示例：
```cpp
template
void swap(T& a, T& b) {
T temp = a;
a = b;
b = temp;
}
```
在这个示例中，我们定义了一个名为swap的函数模板，它可以交换任意类型的值。其中，typename T表示T是一个类型参数，可以在函数调用时根据实际情况确定。
除了函数模板外，C++还支持类模板，它可以用于定义通用的类，以适应不同的数据类型。
友元(friend)是一种额外的访问控制方式，可以让一个函数或类访问另一个类的私有成员。友元机制可以在保护类的私有成员封装性的同时，允许某些函数或类访问这些成员，从而使得程序更加灵活。
下面是一个简单的友元示例：
```cpp
class Box {
private:
int width;
public:
Box(int w) { width = w; }
friend void printWidth(Box box); // 声明友元函数
};
void printWidth(Box box) { // 定义友元函数
cout << "Box width is: " << box.width << endl;
}
int main() {
Box box(10);
printWidth(box); // 可以访问私有成员
return 0;
}
```
在这个示例中，我们定义了一个名为Box的类，它有一个私有成员width。然后我们声明了一个友元函数printWidth，使其可以访问Box类的私有成员。在main函数中，我们创建了一个Box对象，并调用了友元函数printWidth，成功访问了Box类的私有成员。
总之，C++中的类还有一些高级特性，例如模板和友元。掌握这些特性可以帮助程序员编写出更加通用、灵活的代码，提高编程效率和可维护性。除了上述特性，C++中的类还有一些其他的高级特性，例如异常处理、运算符重载和移动语义等。
异常处理(exception handling)是一种错误处理机制，可以在程序出现异常情况时，将控制权转移到指定的处理代码中。C++中的异常处理机制使用try-catch块实现，可以捕获并处理各种类型的异常。
下面是一个简单的异常处理示例：
```cpp
double divide(double a, double b) {
if (b == 0) {
throw "Division by zero!"; // 抛出异常
}
return a / b;
}
int main() {
double x = 10, y = 0;
try {
double z = divide(x, y); // 可能会抛出异常
cout << z << endl;
} catch (const char* msg) { // 捕获异常
cerr << msg << endl;
}
return 0;
}
```
在这个示例中，我们定义了一个名为divide的函数，用于计算两个数的商。如果除数为0，则会抛出一个字符串类型的异常。然后，在main函数中，我们调用divide函数，并用try-catch块包裹起来，以处理可能抛出的异常。
运算符重载(operator overloading)是一种重定义运算符行为的机制，它可以使得用户自定义类型支持内置类型的操作符，例如“+”、“-”等。通过运算符重载，可以让代码更加清晰、简洁，提高可读性和可维护性。
下面是一个简单的运算符重载示例：
```cpp
class Vector {
public:
double x, y;
Vector(double a, double b) {
x = a;
y = b;
}
Vector operator+(const Vector& v) { // 重载“+”运算符
return Vector(x + v.x, y + v.y);
}
};
int main() {
Vector v1(1, 2), v2(3, 4);
Vector v3 = v1 + v2; // 使用重载的“+”运算符
cout << v3.x << ", " << v3.y << endl;
return 0;
}
```
在这个示例中，我们定义了一个名为Vector的类，它有两个成员变量x和y，表示二维向量的坐标。然后，我们重载了“+”运算符，使得Vector类型支持向量加法。在main函数中，我们创建了两个向量对象v1和v2，并使用重载的“+”运算符计算它们的和。
移动语义(move semantics)是一种优化机制，可以减少对象拷贝时的开销。在C++11标准中，引入了右值引用(rvalue reference)和移动构造函数(move constructor)等新特性，以实现更加高效的对象拷贝和转移。
下面是一个简单的移动语义示例：
```cpp
class MyString {
private:
char* data;
public:
MyString(const char* str) { // 构造函数，分配内存并初始化
data = new char[strlen(str) + 1];
strcpy(data, str);
}
~MyString() { // 析构函数，释放内存
delete[] data;
}
MyString(MyString&& other) { // 移动构造函数，转移资源
data = other.data;
other.data = nullptr;
}
};
int main() {
MyString str1("hello");
MyString str2(std::move(str1)); // 调用移动构造函数
return 0;
}
```
在这个示例中，我们定义了一个名为MyString的类，表示字符串类。然后，我们实现了一个移动构造函数，在对象拷贝时直接转移资源，避免了不必要的内存分配和拷贝。在main函数中，我们创建了两个MyString对象，并使用std::move函数将第一个对象的资源转移到第二个对象中。
总之，C++中的类还有许多其他高级特性，例如异常处理、运算符重载和移动语义等。这些特性可以帮助程序员编写出更加高效、灵活的代码，提高开发效率和可维护性。掌握这些特性可以让程序员写出更加优秀的代码，提升职业发展空间。除了上述特性，C++中的类还有一些其他的高级特性，例如多态、虚函数和抽象类等。
多态(polymorphism)是一种面向对象编程的基本概念，它可以使得不同类型的对象表现出相同的行为。在C++中，多态性主要通过虚函数(virtual function)来实现。
虚函数是一种特殊的成员函数，它可以被子类重写，并且在运行时动态绑定到正确的函数，以实现多态性。使用虚函数可以让程序更加灵活，可扩展性更好。
下面是一个简单的虚函数示例：
```cpp
class Shape {
public:
virtual double getArea() { // 声明虚函数
return 0;
}
};
class Rectangle : public Shape {
private:
double width, height;
public:
Rectangle(double w, double h) {
width = w;
height = h;
}
double getArea() override { // 重写虚函数
return width * height;
}
};
class Circle : public Shape {
private:
double radius;
public:
Circle(double r) {
radius = r;
}
double getArea() override { // 重写虚函数
return 3.1415926 * radius * radius;
}
};
int main() {
Shape* shapes[2];
shapes[0] = new Rectangle(3, 4);
shapes[1] = new Circle(5);
for (int i = 0; i < 2; i++) {
cout << "Area of Shape " << i + 1 << " is: " << shapes[i]->getArea() << endl; // 动态绑定
}
return 0;
}
```
在这个示例中，我们定义了一个名为Shape的基类，它有一个虚函数getArea，用于计算面积。然后，我们定义了两个子类Rectangle和Circle，分别重写了getArea函数。在main函数中，我们创建了两个Shape指针对象，并将其指向不同的子类对象，以实现多态性。
抽象类(abstract class)是一种不能被实例化的类，它仅仅用于提供接口和基础实现，并且要求子类必须实现某些方法。在C++中，可以通过将一个或多个成员函数声明为纯虚函数(pure virtual function)来定义抽象类。
下面是一个简单的抽象类示例：
```cpp
class Animal {
public:
virtual void makeSound() = 0; // 声明纯虚函数
};
class Dog : public Animal {
public:
void makeSound() override { // 实现纯虚函数
cout << "Woof!" << endl;
}
};
class Cat : public Animal {
public:
void makeSound() override { // 实现纯虚函数
cout << "Meow!" << endl;
}
};
int main() {
Animal* animals[2];
animals[0] = new Dog();
animals[1] = new Cat();
for (int i = 0; i < 2; i++) {
animals[i]->makeSound(); // 动态绑定
}
return 0;
}
```
在这个示例中，我们定义了一个名为Animal的抽象类，它有一个纯虚函数makeSound，用于发出声音。然后，我们定义了两个子类Dog和Cat，并分别实现了makeSound函数。在main函数中，我们创建了两个Animal指针对象，并将其指向不同的子类对象，以实现多态性。
总之，C++中的类还有许多其他高级特性，例如多态、虚函数和抽象类等。这些特性可以帮助程序员编写出更加灵活、可扩展的代码，提高开发效率和可维护性。掌握这些特性可以使得程序员写出更加优秀的代码，并有利于职业发展。除了上述特性，C++中的类还有一些其他的高级特性，例如多态、虚函数和抽象类等。
多态(polymorphism)是一种面向对象编程的基本概念，它可以使得不同类型的对象表现出相同的行为。在C++中，多态性主要通过虚函数(virtual function)来实现。
虚函数是一种特殊的成员函数，它可以被子类重写，并且在运行时动态绑定到正确的函数，以实现多态性。使用虚函数可以让程序更加灵活，可扩展性更好。
下面是一个简单的虚函数示例：
```cpp
class Shape {
public:
virtual double getArea() { // 声明虚函数
return 0;
}
};
class Rectangle : public Shape {
private:
double width, height;
public:
Rectangle(double w, double h) {
width = w;
height = h;
}
double getArea() override { // 重写虚函数
return width * height;
}
};
class Circle : public Shape {
private:
double radius;
public:
Circle(double r) {
radius = r;
}
double getArea() override { // 重写虚函数
return 3.1415926 * radius * radius;
}
};
int main() {
Shape* shapes[2];
shapes[0] = new Rectangle(3, 4);
shapes[1] = new Circle(5);
for (int i = 0; i < 2; i++) {
cout << "Area of Shape " << i + 1 << " is: " << shapes[i]->getArea() << endl; // 动态绑定
}
return 0;
}
```
在这个示例中，我们定义了一个名为Shape的基类，它有一个虚函数getArea，用于计算面积。然后，我们定义了两个子类Rectangle和Circle，分别重写了getArea函数。在main函数中，我们创建了两个Shape指针对象，并将其指向不同的子类对象，以实现多态性。
抽象类(abstract class)是一种不能被实例化的类，它仅仅用于提供接口和基础实现，并且要求子类必须实现某些方法。在C++中，可以通过将一个或多个成员函数声明为纯虚函数(pure virtual function)来定义抽象类。
下面是一个简单的抽象类示例：
```cpp
class Animal {
public:
virtual void makeSound() = 0; // 声明纯虚函数
};
class Dog : public Animal {
public:
void makeSound() override { // 实现纯虚函数
cout << "Woof!" << endl;
}
};
class Cat : public Animal {
public:
void makeSound() override { // 实现纯虚函数
cout << "Meow!" << endl;
}
};
int main() {
Animal* animals[2];
animals[0] = new Dog();
animals[1] = new Cat();
for (int i = 0; i < 2; i++) {
animals[i]->makeSound(); // 动态绑定
}
return 0;
}
```
在这个示例中，我们定义了一个名为Animal的抽象类，它有一个纯虚函数makeSound，用于发出声音。然后，我们定义了两个子类Dog和Cat，并分别实现了makeSound函数。在main函数中，我们创建了两个Animal指针对象，并将其指向不同的子类对象，以实现多态性。
总之，C++中的类还有许多其他高级特性，例如多态、虚函数和抽象类等。这些特性可以帮助程序员编写出更加灵活、可扩展的代码，提高开发效率和可维护性。掌握这些特性可以使得程序员写出更加优秀的代码，并有利于职业发展。除了上述特性，C++中的类还有一些其他的高级特性，例如移动语义、智能指针和并发编程等。
移动语义(move semantics)是一种用于优化对象拷贝和赋值操作的技术。在C++11之前，对象的拷贝和赋值都是通过复制构造函数(copy constructor)和赋值运算符(assignment operator)来实现的，这会导致创建新对象和销毁旧对象，从而浪费时间和资源。使用移动语义可以避免这些问题，提高效率和性能。
下面是一个简单的移动语义示例：
```cpp
class String {
private:
char* data; // 字符串数据
public:
String(const char* str) { // 构造函数
int len = strlen(str);
data = new char[len + 1];
strcpy(data, str);
}
String(String&& other) { // 移动构造函数
data = other.data;
other.data = nullptr;
}
~String() { // 析构函数
if (data) {
delete[] data;
}
}
};
int main() {
String s1 = "hello";
String s2 = std::move(s1); // 使用移动构造函数
return 0;
}
```
在这个示例中，我们定义了一个名为String的类，它有一个构造函数、一个移动构造函数和一个析构函数。在main函数中，我们创建了两个String对象s1和s2，并使用std::move函数将s1移动到s2中，以实现移动语义。
智能指针(smart pointer)是一种自动化管理内存的技术，可以避免内存泄漏和野指针等问题。在C++中，智能指针主要有三种类型：unique_ptr、shared_ptr和weak_ptr，分别用于实现独占所有权、共享所有权和弱引用。
下面是一个简单的智能指针示例：
```cpp
class Person {
public:
string name;
int age;
Person(string n, int a) : name(n), age(a) {}
};
int main() {
unique_ptr
shared_ptr
weak_ptr
if (auto sp = p3.lock()) { // 使用lock函数获取shared_ptr
cout << sp->name << " is " << sp->age << " years old." << endl;
}
return 0;
}
```
在这个示例中，我们定义了一个名为Person的类，它有一个构造函数和两个成员变量(name和age)。然后，在main函数中，我们使用unique_ptr和shared_ptr分别创建了两个Person对象p1和p2，并使用weak_ptr创建了一个弱引用p3。最后，我们使用lock函数获取p3对应的shared_ptr，并输出其中的信息。
并发编程(concurrency programming)是一种利用多线程技术来提高程序性能和响应速度的编程范式。在C++中，可以使用std::thread、std::mutex、std::condition_variable等类来实现多线程编程和同步机制。
下面是一个简单的并发编程示例：
```cpp
#include
#include
#include
using namespace std;
int counter = 0;
mutex mtx; // 定义互斥锁
void increment() {
for (int i = 0; i < 100000; i++) {
unique_lock
counter++; // 计数器自增
}
}
int main() {
thread t1(increment);
thread t2(increment);
t1.join();
t2.join();
cout << "The value of counter is: " << counter << endl;
return 0;
}
```
在这个示例中，我们定义了一个名为counter的全局变量，并使用std::mutex类定义了一个互斥锁mtx。然后，我们定义了一个名为increment的函数，它包含一个循环，用于将计数器自增。在该函数中，我们使用unique_lock类对互斥锁进行加锁操作，以保证线程安全。最后，在main函数中，我们创建了两个线程t1和t2，分别调用increment函数，并使用join函数等待线程结束。最终，我们输出了计数器的值。
总之，C++中的类还有许多其他高级特性，例如移动语义、智能指针和并发编程等。这些特性可以帮助程序员编写出更加高效、安全的代码，提高开发效率和可维护性。掌握这些特性可以让程序员写出更加优秀的代码，并有利于职业发展。另外，C++中的模板(template)也是一项非常重要的特性。模板可以将函数或类的实现与其所操作的数据类型分离开来，从而实现代码复用和泛型编程。
在C++中，有两种类型的模板：函数模板和类模板。函数模板是一种通用的函数定义，可以用于多种不同类型的参数。类模板是一种通用的类定义，可以用于多种不同类型的成员变量和成员函数。
下面是一个简单的函数模板示例：
```cpp
template
T max(T a, T b) {
return a > b ? a : b;
}
int main() {
int x = 1, y = 2;
double d1 = 1.5, d2 = 2.5;
cout << "The max of " << x << " and " << y << " is " << max(x, y) << endl;
cout << "The max of " << d1 << " and " << d2 << " is " << max(d1, d2) << endl;
return 0;
}
```
在这个示例中，我们定义了一个名为max的函数模板，它接受两个参数a和b，并返回其中较大的值。参数类型使用typename关键字进行声明。然后，在main函数中，我们调用了max函数，并传入了不同类型的参数。由于max是一个函数模板，它能够自动适应不同类型的参数，并返回正确的结果。
下面是一个简单的类模板示例：
```cpp
template
class Array {
private:
T* data;
int size;
public:
Array(int n) : size(n) {
data = new T[n];
}
T& operator[](int index) {
if (index >= 0 && index < size) {
return data[index];
} else {
throw out_of_range("Index out of range!");
}
}
~Array() {
delete[] data;
}
};
int main() {
Array
for (int i = 0; i < 5; i++) {
arr1[i] = i * i;
}
Array
arr2[0] = 1.0;
arr2[1] = 2.0;
arr2[2] = 3.0;
cout << "The values in arr1 are: ";
for (int i = 0; i < 5; i++) {
cout << arr1[i] << " ";
}
cout << endl;
cout << "The values in arr2 are: ";
for (int i = 0; i < 3; i++) {
cout << arr2[i] << " ";
}
cout << endl;
return 0;
}
```
在这个示例中，我们定义了一个名为Array的类模板，它有一个私有成员变量data和一个公有成员函数operator[]，用于访问和修改数组元素。在main函数中，我们创建了两个不同类型的Array对象arr1和arr2，并使用operator[]函数对其元素进行操作。由于Array是一个类模板，它能够适应不同类型的数据，并正确地执行相应的操作。
总之，C++中的模板是一项非常重要的特性，可以实现代码复用和泛型编程。函数模板和类模板都能够自动适应不同类型的数据，并执行相应的操作。掌握模板技术可以让程序员编写出更加灵活、通用的代码，提高开发效率和可维护性。