类与对象知识总结+封闭类+const+this指针 C++程序设计与算法笔记总结（三） 北京大学 郭炜

//C++程序到C程序的翻译

class CCar {
    
    
public:
int price;
void SetPrice(int p);
};
void CCar::SetPrice(int p) 
{
    
     price = p; }
int main()
{
    
    
CCar car;
car.SetPrice(20000);
return 0;
}

struct CCar {
    
     
int price; 
};
void SetPrice(struct CCar * this,
int p)
{
    
     this->price = p; }
int main() {
    
    
struct CCar car;
SetPrice( & car, 
20000);
return 0;
}

this指针作用

其作用就是指向成员函数所作用的对象

非静态成员函数中可以直接使用this来代表指向该函数作用的对象的指针。

class Complex {
    
    
public:
double real, imag;
void Print() {
    
     cout << real << "," << imag ; }
Complex(double r,double i):real(r),imag(i) 
{
    
     }
Complex AddOne() {
    
    
this->real ++; //等价于 real ++;
this->Print(); //等价于 Print
return * this;
} 
}; 
int main() {
    
    
Complex c1(1,1),c2(0,0);
c2 = c1.AddOne();
return 0;
} //输出 2,1

class A
{
    
     
int i;
public: 
void Hello() {
    
     cout << i << "hello" << endl; } 
};  void Hello(A * this ) {
    
     cout << this->i << "hello" 
<< endl; } 
//this若为NULL，则出错！！
int main() 
{
    
     
A * p = NULL;
p->Hello();  Hello(p);
} // 输出：hello

在C++中，this指针是一个特殊的指针，它指向当前对象的地址。它可以在类的成员函数中使用，用于访问调用该函数的对象的成员变量和成员函数。
当类的成员函数被调用时，编译器会隐式地传递一个this指针作为参数给该函数，以便让函数知道它是哪个对象的成员函数被调用了。通过this指针，我们可以在成员函数中访问对象的成员变量和其他成员函数。
举个例子，假设有一个名为"Person"的类，其中有一个成员变量name和一个成员函数printName()，那么在printName()函数中，可以使用this指针来访问name成员变量，如下所示：

class Person {
    
    
private:
    std::string name;
public:
    void setName(std::string n) {
    
    
        this->name = n;
    }
    void printName() {
    
    
        std::cout << "My name is: " << this->name << std::endl;
    }
};

在上面的例子中，this->name表示当前对象的name成员变量，this->name = n表示将传入的n赋值给当前对象的name成员变量。
需要注意的是，this指针只能在非静态成员函数中使用。静态成员函数没有this指针，因为它们不属于任何具体的对象。
总结一下，this指针在C++中用于访问当前对象的成员变量和成员函数，它是一个隐含传递给成员函数的指针。通过this指针，可以方便地操作和使用对象的成员。

在C++中，this指针是一个特殊的指针，它指向当前对象的地址。它可以在类的成员函数中使用，用于访问调用该函数的对象的成员变量和成员函数。
当类的成员函数被调用时，编译器会隐式地传递一个this指针作为参数给该函数，以便让函数知道它是哪个对象的成员函数被调用了。通过this指针，我们可以在成员函数中访问对象的成员变量和其他成员函数。
举个例子，假设有一个名为"Person"的类，其中有一个成员变量name和一个成员函数printName()，那么在printName()函数中，可以使用this指针来访问name成员变量，如下所示：

class Person {
    
    
private:
    std::string name;
public:
    void setName(std::string n) {
    
    
        this->name = n;
    }
    void printName() {
    
    
        std::cout << "My name is: " << this->name << std::endl;
    }
};

在上面的例子中，this->name表示当前对象的name成员变量，this->name = n表示将传入的n赋值给当前对象的name成员变量。
需要注意的是，this指针只能在非静态成员函数中使用。静态成员函数没有this指针，因为它们不属于任何具体的对象。

当涉及到多个对象之间的交互时，this指针也非常有用。通过使用this指针，我们可以将一个对象作为参数传递给另一个对象的成员函数，从而实现对象之间的通信。
举个例子，假设我们有两个类：Student和Teacher。在Teacher类中，我们定义了一个成员函数addStudent()，用于向Teacher对象中添加一个Student对象。代码如下所示：

class Student {
    
    
private:
    std::string name;
public:
    Student(std::string n) : name(n) {
    
    }
    std::string getName() {
    
    
        return name;
    }
};
class Teacher {
    
    
private:
    std::vector<Student> students;
public:
    void addStudent(Student& student) {
    
    
        students.push_back(student);
        std::cout << "Added student: " << student.getName() << std::endl;
    }
};

在上面的例子中，addStudent()函数接受一个Student对象的引用作为参数。通过使用this指针，我们可以在Teacher对象中调用该函数，并将当前Teacher对象作为参数传递给addStudent()函数，从而将自己添加到Teacher对象的students容器中。
使用示例如下：

int main() {
    
    
    Teacher teacher;
    Student student1("Alice");
    teacher.addStudent(student1);
    Student student2("Bob");
    teacher.addStudent(student2);
    return 0;
}

在上述示例中，我们创建了一个Teacher对象teacher，并创建了两个Student对象student1和student2。然后，我们通过调用teacher的addStudent()函数，将student1和student2添加到teacher对象的students容器中。

这个例子展示了如何使用this指针在对象之间传递信息，实现对象之间的交互。通过this指针，我们可以方便地操作其他对象的成员函数和成员变量。

this指针和静态成员函数

静态成员函数中不能使用 this 指针！

因为静态成员函数并不具体作用与某个对象!

因此，静态成员函数的真实的参数的个数，就是程序中写出的参数个数！

在C++中，this指针和静态成员函数之间有一些区别。

1. 静态成员函数没有this指针：由于静态成员函数不属于任何特定的对象，它们没有this指针。因此，在静态成员函数中不能使用this指针来访问对象的成员变量或其他非静态成员函数。
2. 静态成员函数可以直接访问静态成员：静态成员函数只能访问静态成员变量和其他静态成员函数。静态成员是与类关联而不是与对象关联的，所以无需实例化对象即可访问。这是因为静态成员在编译时已经被分配了内存空间。
3. 非静态成员函数可以访问this指针：非静态成员函数可以使用this指针来访问调用该函数的对象的成员变量和其他非静态成员函数。this指针是一个隐式传递给非静态成员函数的指针，它指向当前对象的地址。

需要注意的是，静态成员函数可以通过类名直接调用，而非静态成员函数必须通过对象来调用。另外，静态成员函数在全局作用域中也是可见的，可以通过类名来访问，而非静态成员函数则需要通过对象或对象指针来访问。

举个例子，假设有一个名为"Math"的类，其中包含一个静态成员变量PI和一个静态成员函数add()，以及一个非静态成员变量num和一个非静态成员函数multiply()。代码如下所示：

class Math {
    
    
public:
    static const double PI;
    static int add(int a, int b) {
    
    
        return a + b;
    }
    int num;
    int multiply(int a, int b) {
    
    
        return a * b;
    }
};
const double Math::PI = 3.14159;

在上述示例中，静态成员变量PI可以直接通过类名访问，如Math::PI。静态成员函数add()也可以通过类名直接调用，如int sum = Math::add(2, 3)。
而非静态成员变量num和非静态成员函数multiply()需要通过对象来访问，如：

Math math;
math.num = 10;
int product = math.multiply(4, 5);

总结一下，this指针只能在非静态成员函数中使用，用于访问当前对象的成员变量和其他非静态成员函数。静态成员函数没有this指针，只能访问静态成员变量和其他静态成员函数。静态成员通过类名直接访问，而非静态成员需要通过对象来访问。

在C++中，静态成员是属于类本身而不是类的实例的成员。静态成员在所有类的对象之间是共享的，它们被存储在静态数据区中，并且在程序运行期间只有一份副本。

静态成员可以是静态成员变量或静态成员函数。

1. 静态成员变量：静态成员变量是与类关联而不是与类的对象关联的。它们由类的所有对象共享，无论创建多少个对象，静态成员变量都只有一个副本。静态成员变量通常用于表示与类相关的全局属性或计数器等。定义静态成员变量时，需要在声明前加上static关键字，并在类外部初始化。

class MyClass {
    
    
public:
    static int count;
};
int MyClass::count = 0; // 静态成员变量的初始化
int main() {
    
    
    MyClass::count++; // 访问静态成员变量使用类名和作用域解析运算符
    return 0;
}

2. 静态成员函数：静态成员函数是与类关联而不是与类的对象关联的函数。它们不操作特定对象的成员变量，也没有this指针。静态成员函数可以直接通过类名调用，无需实例化对象。静态成员函数通常用于执行与类相关的一般操作，而不依赖于特定对象。

class MyClass {
    
    
public:
    static void printMessage() {
    
    
        std::cout << "This is a static member function." << std::endl;
    }
};
int main() {
    
    
    MyClass::printMessage(); // 调用静态成员函数使用类名和作用域解析运算符
    return 0;
}

需要注意的是，静态成员变量和静态成员函数都属于类本身，而不是类的对象。因此，在静态成员函数中不能直接访问非静态成员变量或非静态成员函数，只能访问其他静态成员。

总结一下，静态成员是属于类本身的成员，与类的对象无关。静态成员变量由类的所有对象共享，并且在程序运行期间只有一个副本。静态成员函数不依赖于特定对象，可以通过类名直接调用。静态成员通常用于表示与类相关的全局属性或执行与类相关的一般操作。

静态成员

普通成员变量每个对象有各自的一份，而静态成员变量一共就一份，为所有对象共享。

普通成员函数必须具体作用于某个对象，而静态成员函数并不具体作用于某个对象。

因此静态成员不需要通过对象就能访问。

在C++中，静态成员是属于类本身而不是类的实例的成员。静态成员在所有类的对象之间是共享的，它们被存储在静态数据区中，并且在程序运行期间只有一份副本。

静态成员可以是静态成员变量或静态成员函数。

1. 静态成员变量：静态成员变量是与类关联而不是与类的对象关联的。它们由类的所有对象共享，无论创建多少个对象，静态成员变量都只有一个副本。静态成员变量通常用于表示与类相关的全局属性或计数器等。定义静态成员变量时，需要在声明前加上static关键字，并在类外部初始化。

class MyClass {
    
    
public:
    static int count;
};
int MyClass::count = 0; // 静态成员变量的初始化
int main() {
    
    
    MyClass::count++; // 访问静态成员变量使用类名和作用域解析运算符
    return 0;
}

2. 静态成员函数：静态成员函数是与类关联而不是与类的对象关联的函数。它们不操作特定对象的成员变量，也没有this指针。静态成员函数可以直接通过类名调用，无需实例化对象。静态成员函数通常用于执行与类相关的一般操作，而不依赖于特定对象。

class MyClass {
    
    
public:
    static void printMessage() {
    
    
        std::cout << "This is a static member function." << std::endl;
    }
};
int main() {
    
    
    MyClass::printMessage(); // 调用静态成员函数使用类名和作用域解析运算符
    return 0;
}

需要注意的是，静态成员变量和静态成员函数都属于类本身，而不是类的对象。因此，在静态成员函数中不能直接访问非静态成员变量或非静态成员函数，只能访问其他静态成员。

总结一下，静态成员是属于类本身的成员，与类的对象无关。静态成员变量由类的所有对象共享，并且在程序运行期间只有一个副本。静态成员函数不依赖于特定对象，可以通过类名直接调用。静态成员通常用于表示与类相关的全局属性或执行与类相关的一般操作。

当使用静态成员时，有一些特性和注意事项需要了解：

1. 静态成员变量的初始化：静态成员变量在类外部进行初始化，通常在源文件中进行。可以通过在类定义之外使用类名和作用域解析运算符来访问和初始化静态成员变量。
2. 静态成员函数的调用：静态成员函数可以直接通过类名和作用域解析运算符来调用，无需实例化对象。它们不操作特定对象的成员变量，也没有this指针。因此，在静态成员函数内部不能直接访问非静态成员变量或非静态成员函数。
3. 访问权限：静态成员可以具有公共、私有或受保护的访问权限修饰符，就像其他类成员一样。可以使用public、private或protected关键字来控制对静态成员的访问权限。
4. 静态成员的作用域和生存周期：静态成员在类的整个生命周期都存在，并且在所有类的对象之间是共享的。静态成员的作用域限于其定义所在的类，可以通过类名和作用域解析运算符来访问。
5. 静态成员的存储位置：静态成员变量在程序运行期间只有一个副本，它们被存储在静态数据区中。因此，无论创建多少个类的对象，静态成员变量始终保持相同的值。
6. 静态成员和非静态成员之间的区别：静态成员属于类本身，而非静态成员属于类的对象。静态成员在所有对象之间共享，而非静态成员每个对象都有自己的副本。此外，静态成员函数没有this指针，无法访问非静态成员。

需要注意的是，静态成员的设计应该遵循一定的规则和原则。静态成员通常用于表示与类相关的全局属性或执行与类相关的一般操作，而不依赖于特定对象的状态。在使用静态成员时，应该明确其适用范围和目的，以保证代码的可读性和可维护性。

总结一下，静态成员是属于类本身的成员，与类的对象无关。静态成员变量在程序运行期间只有一个副本，静态成员函数可以直接通过类名调用。静态成员通常用于表示与类相关的全局属性或执行与类相关的一般操作。在使用静态成员时，应注意初始化、访问权限、作用域、生存周期等特性。

如何访问静态成员

如何访问静态成员

1) 类名::成员名
CRectangle::PrintTotal();
1) 对象名.成员名
CRectangle r; r.PrintTotal();
1) 指针->成员名
CRectangle * p = &r; p->PrintTotal();
1) 引用.成员名
CRectangle & ref = r; int n = ref.nTotalNumber; 

要访问静态成员变量和静态成员函数，可以使用类名和作用域解析运算符来进行访问。

1. 访问静态成员变量：使用类名和作用域解析运算符::来访问静态成员变量。例如，如果有一个名为MyClass的类，并且该类包含一个静态成员变量staticVar，可以通过MyClass::staticVar来访问它。

class MyClass {
    
    
public:
    static int staticVar;
};
int MyClass::staticVar = 10; // 初始化静态成员变量
int main() {
    
    
    int value = MyClass::staticVar; // 访问静态成员变量
    return 0;
}

2. 调用静态成员函数：同样地，使用类名和作用域解析运算符::来调用静态成员函数。例如，如果有一个名为MyClass的类，并且该类包含一个静态成员函数staticFunc，可以通过MyClass::staticFunc()来调用它。

class MyClass {
    
    
public:
    static void staticFunc() {
    
    
        // 静态成员函数的实现
    }
};
int main() {
    
    
    MyClass::staticFunc(); // 调用静态成员函数
    return 0;
}

需要注意的是，静态成员变量和静态成员函数在编译期间就已经存在，无需实例化对象即可访问和调用。它们不依赖于特定对象的状态，因此可以直接通过类名进行访问。

总结一下，要访问静态成员变量和调用静态成员函数，使用类名和作用域解析运算符::来进行访问和调用。静态成员变量和静态成员函数在编译期间就已经存在，并且无需实例化对象即可访问和调用。

除了使用类名和作用域解析运算符来访问静态成员，还有其他几种方式可以进行访问。

1. 通过对象访问静态成员：虽然静态成员是与类关联而不是与对象关联的，但实际上也可以通过对象来访问静态成员。这是因为在编译器中，对象会自动转换为对应的类类型指针，从而可以使用指针来访问静态成员。

class MyClass {
    
    
public:
    static int staticVar;
};
int MyClass::staticVar = 10; // 初始化静态成员变量
int main() {
    
    
    MyClass obj;
    int value = obj.staticVar; // 通过对象访问静态成员变量
    return 0;
}

尽管可以通过对象访问静态成员，但这样做并不推荐，因为它可能会造成混淆，并且容易让人误以为静态成员是与对象相关联的。
2. 通过指针访问静态成员：与使用对象类似，可以使用指向类类型的指针来访问静态成员。这里需要注意的是，由于静态成员不依赖于特定对象的状态，可以直接通过类名来访问，无需通过指针间接访问。

class MyClass {
    
    
public:
    static int staticVar;
};
int MyClass::staticVar = 10; // 初始化静态成员变量
int main() {
    
    
    MyClass* ptr = nullptr;
    int value = ptr->staticVar; // 通过指针访问静态成员变量
    return 0;
}

需要注意的是，在使用对象或指针访问静态成员时，静态成员的访问权限仍然适用。如果静态成员是私有的，则无法通过对象或指针进行访问。

除了使用类名和作用域解析运算符来访问静态成员外，还可以通过对象或指针来访问。但这些方式并不推荐，因为静态成员是与类关联而不是与对象关联的。最佳实践是直接使用类名来访问静态成员，以确保清晰明确。

静态成员变量本质上是全局变量，哪怕一个对象都不存在，类的静态成员变量也存在。

静态成员函数本质上是全局函数。

设置静态成员这种机制的目的是将和某些类紧密相关的全局变量和函数写到类里面，看上去像一个整体，易于维护和理解。

注意事项

在静态成员函数中，不能访问非静态成员变量，也不能调用非静态成员函数。

void CRectangle::PrintTotal()
{
    
    
cout << w << "," << nTotalNumber << "," << 
nTotalArea << endl; //wrong
}

示例：

确实，你可以使用静态成员变量和静态成员函数来封装总数和总面积，并确保在整个程序中只有一个副本。
下面是一个示例代码：

class Rectangle {
    
    
private:
    int width;
    int height;
    static int totalCount;
    static int totalArea;
public:
    Rectangle(int w, int h) : width(w), height(h) {
    
    
        totalCount++;
        totalArea += width * height;
    }
    static int getTotalCount() {
    
    
        return totalCount;
    }
    static int getTotalArea() {
    
    
        return totalArea;
    }
};
int Rectangle::totalCount = 0;
int Rectangle::totalArea = 0;
int main() {
    
    
    Rectangle rect1(10, 20);
    Rectangle rect2(5, 15);
    int count = Rectangle::getTotalCount();
    int area = Rectangle::getTotalArea();
    return 0;
}

在上述示例中，我们定义了一个Rectangle类，其中包含私有的width和height成员变量，以及静态的totalCount和totalArea成员变量。构造函数会在创建每个矩形对象时自动增加totalCount，并将面积累加到totalArea中。通过静态成员函数getTotalCount()和getTotalArea()，我们可以获取整个程序中所有矩形的总数和总面积。

使用静态成员封装这些变量的好处是，它们与类相关联，并且在整个程序中只有一个副本。这样可以更容易地理解和维护代码，确保数据的一致性。

需要注意的是，静态成员变量和静态成员函数可以在类的定义中声明，在类外部初始化。并且它们不依赖于特定对象的状态，因此可以直接通过类名来访问。

总结一下，使用静态成员变量和静态成员函数可以封装总数和总面积，并确保在整个程序中只有一个副本。这样可以更容易地理解和维护代码，同时保持数据的一致性。

成员对象和封闭类

在C++中，成员对象和封闭类是一种关系，其中封闭类包含一个成员对象作为其成员之一。这种关系可以通过将另一个类的对象声明为封闭类的成员变量来实现。

通过使用成员对象，封闭类可以利用其他类提供的功能，并且可以访问成员对象的成员变量和成员函数。这样，封闭类可以将其他类的功能组合在一起，以实现更复杂的行为。

上例中，如果 CCar类不定义构造函数， 则下面的语句会编译出错：

CCar car;

因为编译器不明白 car.tyre该如何初始化。car.engine 的初始化没问题，用默认构造函数即可。

任何生成封闭类对象的语句，都要让编译器明白，对象中的成员对象，是如何初始化的。

具体的做法就是：通过封闭类的构造函数的初始化列表。

成员对象初始化列表中的参数可以是任意复杂的表达式，可以包括函数，变量，只要表达式中的函数或变量有定义就行。

下面是一个示例代码：

class Engine {
    
    
public:
    void start() {
    
    
        // 引擎启动逻辑
    }
};
class Car {
    
    
private:
    Engine engine;
public:
    void startCar() {
    
    
        engine.start();
        // 其他汽车启动逻辑
    }
};

在上述示例中，Car类包含一个Engine对象作为其成员变量。通过将Engine对象声明为Car类的成员变量，Car类可以使用Engine类提供的start()函数来启动引擎。在Car类的startCar()函数中，我们可以调用engine对象的start()函数来启动引擎，并执行其他与汽车启动相关的逻辑。

使用成员对象和封闭类的好处是可以实现代码的模块化和可重用性。封闭类可以通过成员对象来获取其他类的功能，并将其组合在一起，从而实现更高级的行为。

需要注意的是，在封闭类的构造函数中，成员对象的构造函数也会被调用。类似地，在封闭类的析构函数中，成员对象的析构函数也会被调用。这确保了成员对象在封闭类的生命周期内正确地进行构造和销毁。

总结一下，成员对象和封闭类是一种关系，其中封闭类包含其他类的对象作为其成员之一。这种关系允许封闭类利用其他类提供的功能，并通过组合来实现更复杂的行为。使用成员对象和封闭类可以实现代码的模块化和可重用性。

在C++中，成员对象和封闭类是一种关系，其中封闭类包含一个成员对象作为其成员之一。这种关系可以通过将另一个类的对象声明为封闭类的成员变量来实现。
通过使用成员对象，封闭类可以利用其他类提供的功能，并且可以访问成员对象的成员变量和成员函数。这样，封闭类可以将其他类的功能组合在一起，以实现更复杂的行为。
下面是一个示例代码：

class Engine {
    
    
public:
    void start() {
    
    
        // 引擎启动逻辑
    }
};
class Car {
    
    
private:
    Engine engine;
public:
    void startCar() {
    
    
        engine.start();
        // 其他汽车启动逻辑
    }
};

在上述示例中，Car类包含一个Engine对象作为其成员变量。通过将Engine对象声明为Car类的成员变量，Car类可以使用Engine类提供的start()函数来启动引擎。在Car类的startCar()函数中，我们可以调用engine对象的start()函数来启动引擎，并执行其他与汽车启动相关的逻辑。

使用成员对象和封闭类的好处是可以实现代码的模块化和可重用性。封闭类可以通过成员对象来获取其他类的功能，并将其组合在一起，从而实现更高级的行为。

在封闭类的构造函数中，成员对象的构造函数也会被调用。类似地，在封闭类的析构函数中，成员对象的析构函数也会被调用。这确保了成员对象在封闭类的生命周期内正确地进行构造和销毁。

成员对象和封闭类是一种关系，其中封闭类包含其他类的对象作为其成员之一。这种关系允许封闭类利用其他类提供的功能，并通过组合来实现更复杂的行为。使用成员对象和封闭类可以实现代码的模块化和可重用性。

封闭类构造函数和析构函数的执行顺序

封闭类对象生成时，先执行所有对象成员的构造函数，然后才执行封闭类的构造函数。

对象成员的构造函数调用次序和对象成员在类中的说明次序一致，与它们在成员初始化列表中出现的次序无关。

当封闭类的对象消亡时，先执行封闭类的析构函数，然后再执行成员对象的析构函数。次序和构造函数的调用次序相反。

封闭类的复制构造函数用于创建一个新的对象，该对象是从现有的同类型对象进行复制而来。在复制构造函数中，通常需要对成员对象进行深拷贝，以确保新对象和原对象拥有独立的资源。

下面是一个示例代码：

class MyClass {
    
    
private:
    int* data;
public:
    MyClass(const MyClass& other) {
    
    
        // 执行深拷贝操作
        data = new int(*other.data);
    }
    // 其他成员函数和构造函数的实现
    ~MyClass() {
    
    
        delete data;
    }
};

在上述示例中，我们定义了一个名为MyClass的封闭类，并在其中包含一个动态分配的int类型数据成员data。在复制构造函数中，我们使用new关键字创建了一个新的int对象，并将其初始化为原对象中data指针指向的值的副本。这样可以确保新对象和原对象具有独立的资源。
需要注意的是，在复制构造函数中，还需要处理其他成员变量的复制，以确保新对象拥有与原对象相同的状态。

此外，当定义自定义的复制构造函数时，还应该考虑以下几点：

1. 深拷贝 vs 浅拷贝：如果成员对象本身包含指针或动态分配的内存，复制构造函数应该执行深拷贝，即创建新的资源副本。如果成员对象是只读或不可变的，可以使用浅拷贝。
2. 异常安全性：在执行深拷贝操作时，应保证异常安全性。即使在复制过程中抛出了异常，也要正确处理资源的释放，以防止内存泄漏或资源泄漏。
3. 赋值运算符重载：除了复制构造函数外，还应该重载赋值运算符（=）以支持对象的赋值操作。赋值运算符重载函数的实现与复制构造函数类似。

总结一下，封闭类的复制构造函数用于创建一个新的对象，并以深拷贝的方式复制成员对象和资源。需要对每个成员变量进行适当的复制操作，以确保新对象和原对象具有独立的状态。同时，还应考虑异常安全性和赋值运算符重载的实现。

友元（friends)

友元分为友元函数和友元类两种

友元（friends）是C++中一种特殊的访问权限，它允许某个类或函数访问另一个类的私有成员。通过将一个类或函数声明为另一个类的友元，可以在友元类或函数中直接访问该类的私有成员。
下面是一个示例代码：

class MyClass {
    
    
private:
    int privateData;
public:
    MyClass() : privateData(0) {
    
    }
    friend class FriendClass;  // 声明FriendClass为MyClass的友元
    void printPrivateData() {
    
    
        std::cout << privateData << std::endl;
    }
};
class FriendClass {
    
    
public:
    void modifyPrivateData(MyClass& obj, int newData) {
    
    
        obj.privateData = newData; // 在FriendClass中直接访问MyClass的私有成员
    }
};
int main() {
    
    
    MyClass obj;
    FriendClass friendObj;
    
    friendObj.modifyPrivateData(obj, 42);
    obj.printPrivateData(); // 输出: 42
    
    return 0;
}

在上述示例中，我们声明了一个名为MyClass的类，并声明了一个名为FriendClass的类为其友元。在FriendClass中，我们可以直接访问MyClass的私有成员privateData，并进行修改。这得益于FriendClass被声明为MyClass的友元。

需要注意的是，友元关系是单向的，即如果类A声明类B为友元，那么类A的成员函数可以访问类B的私有成员，但类B的成员函数不能自动访问类A的私有成员。如果需要相互访问，需要进行相应的声明。

此外，友元关系是一种破坏封装性的机制，因此应该谨慎使用。合理使用友元可以提供对类的特定部分的访问权限，使得某些操作更方便，但也可能导致代码的可维护性和安全性降低。

总结一下，C++中的友元机制允许一个类或函数访问另一个类的私有成员。通过将一个类或函数声明为另一个类的友元，在友元类或函数中可以直接访问被授权类的私有成员。友元关系是单向的，并且应该谨慎使用，以避免破坏封装性和引入安全问题。

**友元关系可以分为两种类型：友元函数（friend function）和友元类（friend class）。

1. 友元函数：友元函数是在一个类中声明的非成员函数，并且被声明为该类的友元。这意味着友元函数可以直接访问该类的私有成员。通过友元函数，可以将某个外部函数与类建立关联，以便在实现特殊操作或提供其他功能时访问类的私有成员。

class MyClass {
    
    
private:
    int privateData;
public:
    friend void friendFunction(MyClass& obj);  // 声明friendFunction为MyClass的友元
    // 其他成员函数和构造函数的实现
};
void friendFunction(MyClass& obj) {
    
    
    obj.privateData = 42;  // 在友元函数中直接访问MyClass的私有成员
}

2. 友元类：友元类是在一个类中声明的另一个类，并且被声明为该类的友元。这意味着友元类的成员函数可以直接访问该类的私有成员。通过友元类，可以使得一个类能够访问另一个类的私有成员，从而实现更灵活的设计和组合。

class FriendClass {
    
    
public:
    void modifyPrivateData(MyClass& obj) {
    
    
        obj.privateData = 42;  // 在FriendClass中直接访问MyClass的私有成员
    }
};
class MyClass {
    
    
private:
    int privateData;
public:
    friend class FriendClass;  // 声明FriendClass为MyClass的友元
    // 其他成员函数和构造函数的实现
};

需要注意的是，友元关系应该被谨慎使用，以确保封装性和安全性。友元关系的目的是为了提供灵活性和特殊情况下的访问权限，但过度使用可能会导致代码不易理解和维护。在设计中，应仔细考虑是否真正需要友元关系，并根据具体需求和设计原则进行选择。

友元类之间的关系不能传递，不能继承。

当使用友元关系时，还需要注意以下几点：

1. 友元的范围：友元关系是通过类而不是对象来建立的。一个类的所有对象都可以访问另一个类的私有成员，只要这个类在其声明中将另一个类声明为友元。
2. 友元的传递性：如果类A声明类B为友元，同时类B声明类C为友元，那么类A的成员函数也可以访问类C的私有成员。这种传递性的友元关系使得在复杂的代码结构中，可以通过一系列的友元声明来实现灵活的访问权限。
3. 函数作为友元：除了类之间可以建立友元关系外，函数也可以被声明为类的友元。这样，该函数就可以直接访问该类的私有成员。函数作为友元可以用于提供特定操作或算法所需的访问权限。
4. 友元关系不具备继承性：友元关系不会被继承。即使派生类继承了基类的友元关系，它自己并不具备对基类私有成员的访问权限。
5. 封装和信息隐藏：友元关系破坏了封装性，因此应谨慎使用。友元关系通常用于某些特殊的情况下，例如需要访问私有成员进行优化或实现特殊的操作。

需要明智地使用友元关系，以平衡代码的封装性和灵活性。友元机制可以提供对类的私有成员的访问权限，但也可能导致代码的可维护性和安全性降低。因此，应该仔细考虑并评估在特定情况下使用友元关系的利弊，并确保其使用符合设计原则和需求。

常量成员函数

如果不希望某个对象的值被改变，则定义该对象的时候可以在前面加 const关键字。

常量成员函数（const member function）是指在类中声明的成员函数，在其声明末尾添加const关键字。常量成员函数承诺不会修改对象的状态，因此它们不能修改类的非静态成员变量，也不能调用非常量成员函数（除非这些成员函数也被声明为常量成员函数）。
常量成员函数对于处理只读操作或者保护数据的完整性很有用，因为它们可以确保在使用常量对象或通过常量引用/指针访问对象时，不会意外地修改对象的状态。
下面是一个示例代码：

class MyClass {
    
    
private:
    int data;
public:
    int getValue() const {
    
    
        // 这是一个常量成员函数，不能修改成员变量
        return data;
    }
    void setValue(int value) {
    
    
        // 非常量成员函数可以修改成员变量
        data = value;
    }
};

在上述示例中，getValue()被声明为常量成员函数，因此它不能修改data成员变量的值。而setValue()是非常量成员函数，可以修改data成员变量。
当你有一个常量对象时，只能调用常量成员函数来访问其成员变量和执行操作。例如：

int main() {
    
    
    const MyClass obj;
    int value = obj.getValue();  // 可以调用常量成员函数
    // obj.setValue(10);  // 错误，常量对象无法调用非常量成员函数
    return 0;
}

需要注意的是，在常量成员函数中不能修改成员变量，也不能调用非常量成员函数，除非这些非常量成员函数也被声明为常量成员函数。

常量成员函数在类中声明的成员函数末尾添加const关键字。它们承诺不会修改对象的状态，因此对于只读操作或保护数据完整性很有用。常量成员函数可以在常量对象或通过常量引用/指针访问对象时调用，并且不能修改成员变量或调用非常量成员函数（除非这些成员函数也被声明为常量成员函数）。

当使用常量成员函数时，还需要注意以下几点：

1. 常量对象调用：常量对象只能调用常量成员函数。这是因为常量对象被视为不可修改的，所以只能使用常量成员函数来访问对象的状态。
2. 重载：常量成员函数和非常量成员函数可以进行重载。如果有两个成员函数，一个是常量成员函数，另一个是同名的非常量成员函数，它们可以根据调用对象的常量性来区分。

class MyClass {
    
    
public:
    int getValue() const {
    
    
        // 常量成员函数
        return 10;
    }
    int getValue() {
    
    
        // 非常量成员函数
        return 20;
    }
};
int main() {
    
    
    const MyClass obj1;
    MyClass obj2;
    int value1 = obj1.getValue();  // 调用常量成员函数
    int value2 = obj2.getValue();  // 调用非常量成员函数
    return 0;
}

3. 返回类型：常量成员函数可以返回实际值，也可以返回常量引用或指针。如果返回一个非常量类型的实际值，它会被复制到调用者的副本中；如果返回常量引用或指针，则避免了无谓的复制。

4. mutable关键字：在常量成员函数中，如果希望修改某些成员变量，可以使用mutable关键字来修饰这些成员变量。被mutable修饰的成员变量可以在常量成员函数中被修改。

class MyClass {
    
    
private:
    mutable int cacheValue;
public:
    int getValue() const {
    
    
        if (cacheValue == 0) {
    
    
            // 计算并缓存值
            cacheValue = calculateValue();
        }
        return cacheValue;
    }
    int calculateValue() const {
    
    
        // 计算值的逻辑
        return 42;
    }
};

在上述示例中，cacheValue成员变量被声明为mutable，因此可以在常量成员函数中更新它的值。
常量成员函数在保护对象状态的同时，也提供了对只读操作的方便访问。通过合理使用常量成员函数，可以增强代码的安全性和可靠性，并遵循面向对象设计的原则。

常量成员函数是指在类中声明的成员函数末尾添加const关键字。它们只能用于常量对象或通过常量引用/指针访问对象，并且不能修改成员变量或调用非常量成员函数（除非这些成员函数也被声明为常量成员函数）。常量成员函数可以进行重载，返回实际值、常量引用或指针，并且可以使用mutable关键字修饰某些成员变量以在常量成员函数中进行修改。

如果一个成员函数中没有调用非常量成员函数，也没有修改成员变量的值，那么，最好将其写成常量成员函数。

对C++中const的说明

在C++中，const是一个关键字，用于指定对象或变量是只读的，即不可修改。它可以应用于不同的上下文中，包括：

1. 对象和变量声明：通过在变量或对象的声明前加上const关键字，可以将其标记为只读。这意味着一旦被初始化，就不能再修改该对象或变量的值。

const int x = 10; // 声明一个只读的整数常量x
const MyClass obj; // 声明一个只读的MyClass对象

2. 函数参数：使用const关键字修饰函数参数，表示该参数在函数内部是只读的，在函数执行过程中不能被修改。

void print(const std::string& str) {
    
    
    // 该函数不能修改str的内容
    std::cout << str << std::endl;
}

3. 成员函数：在成员函数后面添加const关键字，表示该成员函数是一个常量成员函数。常量成员函数承诺不会修改对象的状态，并且只能调用其他常量成员函数或访问类的只读成员变量。

class MyClass {
    
    
public:
    void foo() const {
    
    
        // 这是一个常量成员函数
        // 不能修改成员变量或调用非常量成员函数
    }
};

4. 返回类型：const关键字也可以用于指定函数或操作符的返回类型是只读的。

const int calculateValue() {
    
    
    // 返回一个只读的整数值
    return 42;
}
const MyClass operator+(const MyClass& obj) const {
    
    
    // 返回一个只读的MyClass对象
    // 不能修改当前对象或调用非常量成员函数
}

const关键字对于增强代码的可读性、安全性和可维护性非常有帮助。它可以避免意外的修改，保护数据的完整性，并提供了更好的接口设计和封装性。

需要注意的是，使用const关键字并不意味着该对象或变量在内存中是只读的，而仅仅表示在代码中对其进行修改是不被允许的。

当使用const关键字时，还有一些细节和注意事项需要考虑：

1. 可以重载非const和const成员函数：在同一个类中，可以同时定义一个非const版本和一个const版本的成员函数。这样，在调用对象为常量或非常量时，编译器会根据调用对象的常量性选择相应的成员函数。

class MyClass {
    
    
public:
    void foo() {
    
    
        // 非const 版本的成员函数
    }
    void foo() const {
    
    
        // const 版本的成员函数
    }
};

2. 常量对象只能调用常量成员函数：常量对象只能调用常量成员函数，因为常量对象被视为只读对象，不允许修改其状态。但非常量对象可以调用常量成员函数和非常量成员函数。

void someFunction(const MyClass& obj) {
    
    
    obj.foo();  // 可以调用常量成员函数
    MyClass nonConstObj;
    nonConstObj.foo();  // 也可以调用非常量成员函数
}

3. 返回类型是const的影响：如果函数返回类型是const，则返回的值通常不能被修改。

const int getValue() {
    
    
    return 42;  // 返回的值是只读的
}
int main() {
    
    
    const int value = getValue();
    // value = 10;  // 错误，value是只读的
    return 0;
}

4. 指针和引用的const：当使用指针或引用时，const关键字可以应用于指针本身或指向的对象。这样可以限制对指针或引用的修改，或者限制被指向的对象的修改。

int x = 10;
const int* ptr = &x;  // 指向常量的指针，不能通过ptr修改x的值
int y = 20;
int* const ref = &y;  // 指向整数的常量指针，不能通过ref修改指针的指向

5. mutable成员变量：mutable关键字可以用于修饰类的成员变量，它表示该成员变量可以在常量成员函数中被修改。

class MyClass {
    
    
private:
    mutable int count;
public:
    void increment() const {
    
    
        ++count;  // 在常量成员函数中可以修改mutable成员变量
    }
};

需要注意的是，const关键字应根据需要和语义正确地应用。它可以提高代码的可读性、安全性和可维护性，但也需要谨慎使用以避免过度使用。正确使用const关键字可以帮助捕捉编程错误、保护数据完整性，并提供更好的接口设计和封装性。

当使用const关键字时，还有一些概念和技巧需要了解：

1. 保证线程安全性：在多线程环境中，常量对象的成员函数是线程安全的。由于常量对象的状态不会被修改，多个线程可以同时访问常量对象的成员函数而无需额外的同步机制。
2. 常量性转换：常量性可以通过类型转换来进行转换。即可以将非常量对象转换为常量对象进行只读操作。这通过将对象引用或指针的类型从非常量改变为常量来实现。

void func(const MyClass& obj) {
    
    
    // 可以接受常量对象作为参数并进行只读操作
}
int main() {
    
    
    MyClass obj;
    const MyClass& constRef = obj;  // 将非常量对象转换为常量引用
    const MyClass* constPtr = &obj;  // 将非常量对象的地址转换为常量指针
    return 0;
}

3. const和函数重载：常量性可以用作函数重载的条件之一。如果一个函数的参数是常量对象或常量引用，那么可以重载该函数以提供对常量对象的特殊处理。

class MyClass {
    
    
public:
    void process() {
    
    
        // 非const 版本的成员函数
    }
    void process() const {
    
    
        // const 版本的成员函数
    }
};
int main() {
    
    
    MyClass obj;
    const MyClass constObj;
    obj.process();      // 调用非const版本的process函数
    constObj.process(); // 调用const版本的process函数
    return 0;
}

4. const修饰符位置：在函数声明中，const关键字可以放在成员函数的后面，也可以放在参数列表的后面。这两种形式的意义是相同的，但通常将const关键字放在函数后面更为常见。

class MyClass {
    
    
public:
    void process() const;   // const放在函数后面
    void update() const;    // const放在参数列表后面
};
void MyClass::process() const {
    
    
    // const成员函数的实现
}
void MyClass::update() const {
    
    
    // const成员函数的实现
}

需要根据具体情况正确使用const关键字。合理使用const可以增强代码的安全性、可读性和可维护性，并帮助捕捉编程错误。它提供了一种约束机制，用于指定只读操作和不会修改对象状态的函数，从而增加了代码的健壮性和可靠性。

常量成员函数的重载

在C++中，常量成员函数可以根据被调用对象的常量性进行重载。这意味着可以定义一个非常量版本和一个常量版本的成员函数，分别用于处理常量对象和非常量对象。
下面是一个示例代码：

class MyClass {
    
    
public:
    void foo() {
    
    
        // 处理非常量对象的逻辑
        std::cout << "Non-const version" << std::endl;
    }
    void foo() const {
    
    
        // 处理常量对象的逻辑
        std::cout << "Const version" << std::endl;
    }
};
int main() {
    
    
    MyClass obj1;
    const MyClass obj2;
    obj1.foo();  // 调用非常量版本的foo函数
    obj2.foo();  // 调用常量版本的foo函数
    return 0;
}

在上述示例中，MyClass类定义了两个名为foo()的成员函数，一个是非常量版本，另一个是常量版本。当调用非常量对象obj1的foo()函数时，会调用非常量版本；而当调用常量对象obj2的foo()函数时，会调用常量版本。

通过使用常量成员函数的重载，可以根据对象的常量性来选择合适的操作方式。这样可以保证对常量对象的只读操作以及非常量对象的修改操作都能得到正确的处理。

需要注意的是，常量成员函数的重载不仅与常量性有关，还与函数的参数类型和数量相关。因此，在进行函数重载时，需要确保函数的签名（包括参数类型、常量性等）是不同的。

总结一下，常量成员函数可以根据对象的常量性进行重载，以提供对常量对象和非常量对象的不同处理。通过合理使用常量成员函数的重载，可以保证对象在不同常量性下得到适当的操作，并增加代码的灵活性和可读性。

mutable成员变量（可以在const成员函数中修改的成员变量）

可以在const成员函数中修改的成员变量

在C++中，mutable关键字用于修饰类的成员变量，它表示该成员变量可以在常量成员函数中被修改，即使这些函数通常是不允许修改对象状态的。
下面是一个示例代码：

class MyClass {
    
    
private:
    mutable int count;
public:
    void increment() const {
    
    
        ++count;  // 在常量成员函数中可以修改mutable成员变量
    }
};

在上述示例中，count成员变量被声明为mutable，这意味着即使在常量成员函数（如increment()）中，也可以对其进行修改。默认情况下，常量成员函数是不允许修改对象的状态的，但使用mutable关键字可以打破这个限制。
mutable关键字适用于那些在实现细节中需要跟踪或缓存信息的成员变量。例如，在某个类中计算并缓存某个值，而不希望每次调用时都重新计算，可以使用mutable来标记该成员变量。
需要注意以下几点：

• mutable只能应用于非静态成员变量，因为静态成员变量是与类而不是对象相关联的。
• mutable成员变量的修改仅限于同一对象内部，并不会影响其他对象的状态。
• 尽管mutable允许在常量成员函数中修改变量，但仍应该谨慎使用。这是因为常量成员函数通常被认为是不会引起对象状态变化的，因此对于需要修改的情况，最好考虑其他可行的设计方案。

总结一下，mutable关键字用于修饰类的成员变量，表示该成员变量可以在常量成员函数中被修改。它在某些情况下提供了更灵活的设计选择，但也应该谨慎使用，以避免滥用导致代码逻辑混乱或违背设计原则。