C++中的运算符重载

C++中的运算符重载是一种特殊的函数，它允许我们改变已有的运算符的行为。在C++中，运算符可以被定义为类的成员函数或全局函数，用于对相应类型的操作数进行特定的计算。运算符重载使得我们能够自定义用户定义类型的行为，以便像内置类型一样使用

​ 在实现运算符重载时，需要注意以下几点：

1. 运算符重载函数必须是类的成员函数或全局函数。
2. 运算符重载函数的名称必须与要重载的运算符相同。
3. 运算符重载函数的参数类型和个数必须与要重载的运算符所接受的参数类型和个数相匹配。
4. 对于二元运算符，可以通过将其定义为类的成员函数或全局函数来交换操作数的顺序。
5. 运算符重载函数应该返回适当的值类型，以便在表达式中使用。

#include<iostream>
#include <ostream>
using namespace std;
class Complex{
    private:
    int real;
    int imag;
    public:    //初始化列表
    Complex(int r = 0,int i = 0):real(r),imag(i){

    }
    //重载 + 运算符
   Complex operator +(const Complex&obj)
   {
             Complex res;
              res.real = real+obj.real;
              res.imag = imag+obj.imag;
              return res;
   }
    //重载 << 运算符
     friend ostream &operator <<(ostream&out,const Complex&obj)
     {
         cout<<obj.real<<"+"<<obj.imag<<endl;
         return out;
     }

};
int main()
{
    Complex s1(2,3);
    Complex s2(4,6);
    Complex res = s1+s2;
    cout<<res<<endl;
    return 0;
}

C++中的友元

在 C++ 中，一个类中可以有 public、protected、private 三种属性的成员，通过对象可以访问 public 成员，只有本类中的函数可以访问本类的 private 成员。友元（friend）可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。

友元语法：

• friend关键字只出现在声明处

• 其它类、类成员函数、全局函数都可声明为友元

• 友元函数不是类的成员，不带 this 指针

• 友元函数可访问对象任意成员属性，包括私有属性

#include<bits/stdc++.h>
using namespace std;
class phone{
    // write your code here......
    friend class myphone;
    private:
        int price;
    public:
        phone(int x){
            price=x;
        }
}; 
class myphone{
    private:
        phone a;
    public:
        myphone(int x):a(x){
        }
        int getprice(){
            return a.price;
        }
};
int main(){
    int p;
    cin>>p;
    myphone a(p);
    cout<<a.getprice();
    return 0;
}

C++中的继承

继承语法

class parent_class
{
    //Body of parent class
};
class child_class : access_modifier parent_class
{
   //Body of child class
};

继承是面向对象编程语言中重要的概念之一，继承的主要优点是提高代码的可重用性和可读性。当子类需要继承父类的成员和函数时，不需要再次写重复的代码；

单一继承

一个类直接继承另一个类

假设当我们有类 A和B

#include<iostream>
using namespace std;
class A {
public:   //单向继承 一个类直接继承一个类
    A()
    {
        cout << "A 的 构造函数调用" << endl;   //优先调用父类构造函数
    }

};

class B :public A   
{
public:
    B()
    {
        cout << "B 的构造函数调用" << endl;
    }

};

int main()
{
    B s;
}

多级继承

多级继承则是指一个类从另一个类继承而来，并且这个类本身又作为另一个类的基类

class Animal {
public:
    void eat() { cout << "Animal eats\n"; }
};

class Mammal : public Animal {
public:
    void sleep() { cout << "Mammal sleeps\n"; }
};

class Dog : public Mammal {
public:
    void bark() { cout << "Dog barks\n"; }
};

C++中的多态

虚函数只是实现多态的一种方式

在 C++ 中，实现多态的一种常用方式是通过使用虚函数（virtual function）。虚函数是一个在基类中声明为虚拟的成员函数，在派生类中重新定义，并可以通过基类指针或引用来调用派生类的函数。

运行时多态

class Animal {
   
public:
    virtual void makeSound() {
    // 定义虚函数
        cout << "This animal makes a sound." << endl;
    }
};

class Cat : public Animal {
   
public:
    void makeSound() {
    // 重新定义虚函数
        cout << "Meow!" << endl;
    }
};

class Dog : public Animal {
   
public:
    void makeSound() {
    // 重新定义虚函数
        cout << "Woof!" << endl;
    }
};

int main() {
   
    Animal* animalPtr; // 声明一个指向 Animal 类型对象的指针

    Cat cat; // 创建 Cat 对象
    Dog dog; // 创建 Dog 对象

    animalPtr = &cat; // 指向 Cat 对象
    animalPtr->makeSound(); // 调用 Cat 的 makeSound() 函数

    animalPtr = &dog; // 指向 Dog 对象
    animalPtr->makeSound(); // 调用 Dog 的 makeSound() 函数

    return 0;
}

在上面的代码中，Animal 类包含一个名为 makeSound() 的虚函数。Cat 和 Dog 类都继承自 Animal 类，并重新定义了 makeSound() 函数。

在主函数中，我们创建了一个指向 Animal 类型对象的指针 animalPtr，并分别将其指向 Cat 和 Dog 对象。通过这种方式，我们可以调用正确的函数（Cat 的 makeSound() 或 Dog 的 makeSound()），即使只使用了指向 Animal 类型对象的指针。这就是多态的实现。

静态多态

先写到这里 ，在这里留个坑。回家会补上的！！！！！