C++ 友元，内部类，运算符重载

2020-11-10 本文已影响0人 lieon

友元

友元包括友元函数和友元类
如果将函数A（非成员函数）声明为类C的友元函数，那么函数A就能直接访问类C对象的所有成员
如果将类A声明为类C的友元类，那么类A的所有成员函数就能直接访问类C对象的所有成员
友元破坏了面向对象的封装性，但在某些频繁访问成员变量的地方可以提高性能
朋友元的就是让一个函数或者类，访问另一个类中的私有成员

class Point {
    // add 是point的友元函数，可以Point类中的所有成员）
    friend Point add(const Point &, const Point &);
    // Math是Point的友元类，Math中可以访问Point类中的所有成员
    friend class Math;
private:
    int m_x;
    int m_y;
    
public:
    Point() {}
    Point(int x, int y): m_x(x), m_y(y) {}
};

Point add(const Point &p1, const Point &p2) {
    return Point(p1.m_x + p2.m_x, p1.m_y + p2.m_y);
}

class Math {
    void test() {
        Point point;
        point.m_x = 20;
        point.m_y = 30;
    }
    
    static void test2() {
        Point point;
        point.m_x = 20;
        point.m_y = 30;
    }
};

内部类

如果将类A定义在类C的内部。那么类A就是一个内部类（嵌套类）
内部类的特点
- 支持public， protected，private权限
- 成员函数可以直接不带类名，对象名访问其外部类的static成员
- 成员函数可以直接访问其外部类对象的所有成员（反过来则不行）
- 不会影响外部内的内存布局
- 可以在外部类内部声明，在外部类外面进行定义

class Point {
private:
    int m_x;
    int m_y;
    static int ms_test2;
    
    static void test1() { }
    
public:
    Point() {}
    Point(int x, int y): m_x(x), m_y(y) {}
    
    class Math {
        void test3() {
            test1();
            ms_test2 = 10;
            
            Point point;
            point.m_y = 20;
            point.m_x = 10;
        }
    };
};

局部类

在一个函数内部定义的类，称为局部类
局部类的特点
- 作用域仅限于所在的函数内部
- 其所有成员必须定义在类内部，不允许定义static成员变量
- 成员函数不能直接访问函数的局部变量（static变量除外）

void test() {
    static int s_age = 0;
    int age = 0;
    
    class Point {
        int m_x;
        int m_y;
    public:
        static void display() {
            s_age = 20;
            // age = 30; // 错误
        }
    };
    
    Point::display();
}

类型转换

C++中建议使用C++的类型转换符取代C风格的强制类型装换
C++中有4个类型转换符: static_cast, dynamin_cast, reinterpret_cast, const_cast

const_cast: 一般用于去掉const属性，将const转换成非const

 const Person *p1 = new Person();
 // p1->m_age = 20; 错误
 
 Person *p2 = const_cast<Person*>(p1);
 p2->m_age = 20;

dynamic_cast:一般用于多态类型的转换，有运行时安全检测

class Person {
public:
    int m_age = 0;
    virtual void run() {}
};

class Student: public Person { };

class Car {};

Student *stu1 = dynamic_cast<Student *>(p1); // NULL
Student *stu2 = dynamic_cast<Student *>(p3);
Car *car = dynamic_cast<Car *>(p1); // NULL

static_cast
- 对比dynamic_cast，缺乏运行时安全检测
- 不能交叉装换（不是统一继承体系的，无法转换）
- 常用用于基础数据类型的转换，非const转成const

Student *stu3 = static_cast<Student *>(p1); // NULL
Student *stu4 = static_cast<Student *>(p3);

//    Car *car = static_cast<Car*>(p1); // 错误

reinterpret_cast
- 属于比较底层的强制转换，没有任何类型检查和格式转换
- 可以交叉转换
- 可以将指针和整数互相转换

Student *stu5 = reinterpret_cast<Student *>(p1);
Student *stu6 = reinterpret_cast<Student *>(p3);

Car *car1 = reinterpret_cast<Car*>(p1);

int *p = reinterpret_cast<int *>(100);
int num = reinterpret_cast<long>(p);

int i = 10;
double d1 = reinterpret_cast<double &>(i);

运算符重载

运算符重载（操作符重载）:可以为运算符增加一些新的功能


class Point {
public:
    int m_x;
    int m_y;
    
    Point(int x, int y);
    Point(const Point &point);
    
    Point operator+(const Point &p1) const;
    Point operator-(const Point &p1) const;
    const Point operator-() const;
    Point &operator+=(const Point &point);
    Point &operator-=(const Point &point);
    bool operator==(const Point &point);
    bool operator!=(const Point &point);
  // 前置递增返回引用
    Point &operator++();
    // 后置递增返回值
    const Point operator++(int);
   Point &operator--();
   const Point operator--(int);
   Point &operator=(const Point &);
   // 函数调用符重载 - 仿函数
   Point &operator()(int, int);
};


Point::Point(int x, int y): m_x(x), m_y(y) {}
Point::Point(const Point &point): m_x(point.m_x), m_y(point.m_y) {}

// 前++: 先加再用
Point &Point::operator++() {
    m_x++;
    m_y++;
    return *this;
}

// 后++：先用再加
const Point Point::operator++(int) {
    Point point(m_x, m_y);
    m_x++;
    m_y++;
    return point;
}

Point Point::operator+(const Point &point) const {
    return Point(m_x + point.m_x, m_y + point.m_y);
}

Point Point::operator-(const Point &p1) const {
    return Point(m_x - p1.m_x, m_y - p1.m_y);
}

const Point Point::operator-() const {
    return Point(-m_x, -m_y);
}

Point &Point::operator+=(const Point &point) {
    m_x += point.m_x;
    m_y += point.m_y;
    return *this;
}

Point &Point::operator-=(const Point &point) {
    m_x -= point.m_x;
    m_y -= point.m_y;
    return *this;
}

bool Point::operator==(const Point &point) {
    return m_x == point.m_x && m_y == point.m_y;
}

bool Point::operator!=(const Point &point) {
    return m_x != point.m_x && m_y != point.m_y;
}

Point & Point::operator--() {
   this->m_x = this->m_x - 1;
   this->m_y = this->m_y - 1;
   return  *this;
}

const Point Point::operator--(int) {
   Point temp = *this;
   m_x = m_x - 1;
   m_y = m_y - 1;
   return temp;
}

Point &Point::operator=(const Point & point) {
   // 应该先判断是否属性在堆区，如果有先释放干净，再进行深拷贝
   /**
    if (m_age != nullptr) {
       delete m_age;
       m_age = nullptr;
    }
    */
   cout << m_x << m_y << endl;
   m_x = point.m_x;
   m_y = point.m_y;
   
   return *this;
}

Point &Point::operator()(int x, int y) {
   m_x = x;
   m_y = y;
   return *this;
}

调用父类的运算符重载函数

class Person {
public:
    int m_age = 0;
    
    Person &operator=(const Person &person) {
        this-> m_age = person.m_age;
        return *this;
    }
};

class Student: public Person {
public:
    int m_score;
    
    Student &operator=(const Student &student) {
        Person::operator=(student);
        this->m_score = student.m_score;
        return *this;
    }
};

仿函数

仿函数：将一个对象当作一个函数一样来使用
对比普通函数，它作为对象可以保存状态

class Sum {
public:
   int operator()(int a, int b) {
       return a + b;
    }
};

void testSum() {
    Sum sum;
    sum(1, 2);
}

运算符重载注意点

有些运算符不可以被重载，比如:
- 对象成员访问运算符: .
- 域运算符号: ::
- 三目运算符: ? :
- sizeof
有些运算符只能重载为成员函数，比如:
- 赋值运算符: =
- 下标运算符：[]
- 函数运算符: ()
- 指针访问成员: ->

C++ 友元，内部类，运算符重载

友元

内部类

局部类

类型转换

运算符重载

仿函数

运算符重载注意点

猜你喜欢

热点阅读