C++学习笔记之类&对象（一）

https://www.runoob.com/cplusplus/cpp-classes-objects.html

类是C++的核心特性，为用户自定义的数据类型，可以在其中放入数据和函数作为成员，并且以此为模板，创建多个对象个体进行使用

1、类&对象

定义类需要使用关键字class，然后为类指定名称，在使用花括号包裹的代码块内部，放置类的成员变量以及成员函数

成员变量表示的是类当中的数据，而成员函数代表的是方法，可以对数据进行各种操作

class Rectangle
{
public:   // 访问属性 
    double length;     // 成员变量
    double width;
};     // 分号结束

以上是一个简单的类定义，其中仅有两个成员变量，分别用以表示矩形的长和宽，这里面并没有声明成员函数，两个变量的访问属性都是public公共的，因此在类外是可以直接借助类的对象进行访问的

通常对于类的使用，是借助于创建对应类的对象进行实现的
我们将类看作一个基本的数据类型的话，对象其实就如同是某个类型的变量一般的存在

Rectangle rect1;   // 类的对象1
Rectangle rect2;   // 类的对象2

创建出的同一个类不同的对象rect1和rect2，它们就如同两部华为Mate60，同样是Mate60的标准生产出来的，但是是两个不同的个体，Mate60这个标准就等同于类的概念，作为一个模板或者说标准，而依照这个标准制造的具体的个体则是对象的概念

2、访问数据成员

class Rectangle
{
public:   // 访问属性 
    double length;
    double width;
    // 成员函数声明
    void set(double l, double w);
    double get();
};
// 成员函数定义
void Rectangle::set(double l, double w)
{
    length = l;
    width = w;
}

double Rectangle::get()
{
    return length * width;
}

对于访问权限为public的成员函数或者成员变量，可以直接通过的类的对象使用.运算符进行访问或者调用

Rectangle rect1;
rect1.length = 8;
rect1.width = 6;
cout << "rect1的面积=" << rect1.get() << endl; 
Rectangle rect2;
rect2.set(12, 5);
cout << "rect2的面积=" << rect2.get() << endl;

3、类的成员函数

其实在上面已经使用到了类的成员函数，而类的成员函数就是指那些把定义和原型写在类定义内部的函数
成员函数可以操作类的任意对象，访问对象中的所有成员

成员函数可以定义在类定义内部，或者单独使用范围解析运算符::定义

class Rectangle
{
public:   // 访问属性 
    double length;
    double width;
    double get()
    {
        return length * width;
    }
};

像上面这样，将函数定义在类定义内部，此时函数被声明为内联，即使没有使用inline标识符

class Rectangle
{
public:   
    double length;
    double width;
    double get();   // 	仅仅进行声明
};

double Rectangle::get()     // 类外对于方法进行具体实现
{
    return length * width;
}

也可以在类的外部使用范围解析运算符::进行具体实现，而在类的内部仅仅声明一下
使用::关联到类，因此需要在前面加上类名，后面则是已经在类中声明的函数名

Rectangle rect1;
rect1.length = 8;
rect1.width = 6;
cout << "rect1的面积=" << rect1.get() << endl; 

最后，通过类的对象进行成员函数的调用

4、类的访问修饰符

类的访问修饰符与面向对象编程的封装有着密切关系，通过使用访问修饰符限制代码对于函数内部成员的直接访问

C++中使用public、private、protected关键字作为访问修饰符
对于一个类来说，可以有多个public、protected、private标记区域，每个标记区域在下一个标记区域开始之前或遇到类主体结束右括号之前都是有效的
成员和类的默认访问修饰符都是private

class Base {
public:
// 公有成员
protected:
// 保护成员
private:
// 私有成员    
};

4.1、public成员

public成员在类的外部是可以直接访问的

class Rectangle
{
public:   // 公共成员
    double length;
    double width;
    double get();
};

double Rectangle::get()
{
    return length * width;
}

int main()
{
        Rectangle rect;
        rect.length = 8;   // 直接访问
        rect.width = 6;
}

4.2、private成员

private成员变量或函数在类的外部是不可访问的，仅可以通过类和友元函数可以访问
一般会在私有区域定义数据，在公有区域定义相关的函数，以便在类的外部也可以调用这些函数

class Rectangle
{  // 默认私有
    double length;
    double width;
public:  
    void setWidth(double w)
    {
        width = w;
    }
    void setLength(double l)
    {
        length = l;
    }
};

int main()
{
    Rectangle rect;
    rect.setWidth(6);
    rect.setLength(8);
}

4.3、protected成员

protected成员变量或函数在子类中式可访问的，这需要涉及到继承相关的概念
protected所代表的关系大概就是一种传承的关系，比如刘备有诸葛亮作为军师，那么诸葛亮可能就是刘备的protected 成员，那么这是刘备专属，别人不能拿去用，但是阿斗继承了刘备，那么这份归属权就交到了阿斗手上，那么诸葛亮也可以是阿斗的军师

class LiuBei {
protected:
    string junShi = "诸葛亮";
};

class ADou : LiuBei {   // 继承
public:
    void work()
    {
        cout << "请" << junShi << "协助办公" << endl;   // 取出父类的protected成员
    };
};

int main()
{
        ADou ad;
        ad.work();
}

4.4、继承中的特点

在C++中，类的继承分为public、private和protected三种方式
以下表示父类对应访问修饰的成员，在继承到子类后对应的访问权限变化情况

• public继承

父类	public	private	protected
子类	public	private	protected

class A
{
    private:
        int a;
    public:
        int b;
    protected:
        int c;        
};

class B : public A  
{
    public:
        void print()
        {
            cout << b << ", " << c << endl;  // a是private，子类不可访问
        }
};

int main()
{
    B bob;
    bob.b = 10;   // b是public，c是protected只能向下传
}

• private继承

父类	public	private	protected
子类	private	private	private

class A
{
    private:
        int a;
    public:
        int b;
    protected:
        int c;            
};

class B : private A   // 可省略，默认是私有继承
{
    public:
        void print()
        {
            cout << b << ", " << c << endl;  // 都是private，bc是子类，a是父类
        }
};

int main()
{
    B bob;   // 全都访问不了
}

• protected继承

父类	public	private	protected
子类	protected	private	protected

class A
{
    private:
        int a;
    public:
        int b;
    protected:
        int c;            
};

class B : protected A
{
    public:
        void print()
        {
            cout << b << ", " << c << endl;
        }
};

int main()
{
    B bob;   // b、c都是protected，只能向下传
}

其中，

• private修饰的成员依然只能由类本身以及友元访问，子类也是无法访问
• protected修饰的成员则是可以被子类访问