C++基础概念

类和对象的特性

C++是面向对象的（object oriented programming—OOP）。强调对象，由对象实施动作。
C是面向过程的（procedure oriented programming—POP）。强调执行的过程。
参考：https://blog.csdn.net/Grace_1203/article/details/79502075

对象：由属性和行为构成

c++ 四大特性

1、封装
1.1、将有关的数据和操作封装在一个对象中，形成一个基本的单位，各个对象之间相对独立，互不干扰。
1.2、将对象中的某些部分对外隐蔽，即隐蔽其内部细节，只留下少量借口，以便与外界联系。信息隐蔽有利于数据安全
2、抽象
抽象的作用是表示同一类事物的本质。例如，我们常用的名词“人”，就是一种抽象。
3、继承与重用
利用已有的类建立新的类。例如，人是父类，欧洲人，亚洲人都具有人的共性，在加上自身的特性就可以描述。这里面，人称为父类或基类，欧洲人，亚洲人称为子类或派生类。这个过程叫继承，这种思想可以称为软件重用。
4、多态性
有继承而产生的不同的派生类，其对象对同一消息会作出不同的相应。例如，父类人有眼睛的特性，子类继承父类的特性。欧洲人调用这个特性时，描述眼睛为蓝色。亚洲人调用这个特性时，描述眼睛为黑色。

内置成员函数（inline）

在函数前加上inline关键字，可以将函数代码拷贝嵌入到函数调用点，没有函数调用过程，可以减少时间开销。如果在类体中定义的函数成员函数中不包括循环等控制结构，c++系统自动地对它们作为内置函数来处理。在类体外需要要指定内置要加上inline
注意：在类体外定义inline函数，则必须将类定义和成员函数的定义放在同一个头文件中，否则编译时无法进行置换

成员函数的存储方式

当用类定义多个对象时，系统会为每一个成员数据分配空间，而对象的方法统一存储在同一个空间中。

https://blog.csdn.net/fuzhongmin05/article/details/59112081

数据成员的初始化

类名：：构造函数名（[参数表]）[：成员初始化表]
{
[构造函数体]
}

class Box
{
public:
	Box::Box(int h,int w,int len):height(h),width(w),lenght(len){}
private:
	int height;
	int width;
	int lenght;
}
//调用
Box test(1,2,3); //height = 1，width = 2，lenght = 3

函数重载

函数的重载的规则：
1、函数名称必须相同。
2、参数列表必须不同（个数不同、类型不同、参数排列顺序不同等）。
3、函数的返回类型可以相同也可以不相同。
4、仅仅返回类型不同不足以成为函数的重载。

析构函数

先构造的后析构，后构造的先析构
当对象中有new时，调用析构时就要delete

~fun() {
        if (p != NULL) {
            delete p;
            p = NULL;
        }
    }

this指针

this指针是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。
例，当调用成员函数temp.width时，编译系统就把对象temp的起始地址赋值给this指针。

常对象

Temp const aa(int a)
类名 const 对象名[ ( 实参表 ) ] 或者 const 类名 对象名[ ( 实参表 ) ]

常成员数据
常对象的生命周期中，所有的数据成员的值都不能被修改，可以调用。
只能通过构造函数的参数初始化表对常数据成员进行初始化。
如果想修改值，可以加上mutable声明变量。

常成员函数
常对象不能调用普通函数对象，只能调用常成员函数。如：temp.fun() 非法，需定义 void fun() const;
特点：
1）可以输出，可以运算，但不能进行修改
2）这种不可修改只针对于类的数据成员，对于函数自身的参数可以进行修改
3）常函数的this指针变成了const 类名*

类的静态成员

静态成员可以被同类一个或几个对象所共享数据。
静态数据成员
内存分配：如果声明了类而未定义对象，则类的一般数据成员是不占内存空间的。而静态数据成员，即使不定义对象，也要分配空间。静态数据成员在内存中只占一份空间
生命周期：一般数据成员是在对象建立时分配空间，在对象撤销时释放。静态数据成员在程序开始时被分配空间，直到程序结束时才释放。
静态数据成员可以初始化，但智能在类体外进行初始化。
静态成员初始化：
数据类型 类名：：静态数据成员名 = 初值
不能用参数初始化表对静态数据成员初始化，可以在类体外进行初始化
静态数据成员既可以通过对象名引用，也可以通过类名引用
静态成员函数
静态成员函数没有this指针
静态成员函数主要用来访问静态数据成员，而不访问非静态成员

class Temp
{
public:
    Temp(int test): aa(test){}//常成员初始化
    const int aa;
    static int bb;
};
int Temp::bb = 5;//静态成员初始化

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    Temp aa(4);
    return a.exec();
}

友元

友元函数
如果在本类以外定义了一个函数（可以是非成员函数，可以是成员函数），在类体中用friend对其进行声明，此函数就称为本类的友元函数，友元函数可以访问这个类中的私有成员

class INTEGER
{
    friend void Print(const INTEGER& obj);//声明友元函数
};

void Print(const INTEGER& obj）
{
    //函数体
}

void main()
{
    INTEGER obj;
    Print(obj);//直接调用
}

友元可以是一个函数，也可以是一个类，该类被称为友元类

模板

函数模板
函数模板就是建立一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。
template 或 template < calss T> 通用函数定义
template 的含义是“模板”，typename （class ）关键字，后面跟一个类型参数T。

template<typename T>
T max( T a,T b,T c)
{
	if(b > a)a = b;
	if(c > a) a = c;
	return a;
}

类模板

template <typename T>
class Complex{
    
public:
    //构造函数
    Complex(T a, T b)
    {
        this->a = a;
        this->b = b;
    }
    
    //运算符重载
    Complex<T> operator+(Complex &c)
    {
        Complex<T> tmp(this->a+c.a, this->b+c.b);
        return tmp;
    }
        
private:
    T a;
    T b;
}

int main()
{
    //对象的定义，必须声明模板类型，因为要分配内容
    Complex<int> a(10,20);  
    Complex<int> b(20,30);
    Complex<int> c = a + b;
    
    return 0;
}

运算符重载

函数类型 operator 运算符名称（形参表）
｛对运算符的重载处理｝

#include <iostream>
using namespace std;
 
class Box
{
   public:
      // 重载 + 运算符，用于把两个 Box 对象相加
      Box operator+(const Box& b)
      {
         Box box;
         box.length = this->length + b.length;
         box.breadth = this->breadth + b.breadth;
         box.height = this->height + b.height;
         return box;
      }
   private:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
};
// 程序的主函数
int main( )
{
   Box Box1;                // 声明 Box1，类型为 Box
   Box Box2;                // 声明 Box2，类型为 Box
   Box Box3;                // 声明 Box3，类型为 Box

   // 把两个对象相加，得到 Box3
   Box3 = Box1 + Box2;
   
   return 0;
}

派生类

单继承：一个派生类只从一个基类派生
多重继承：一个派生类有两个或多个基类

在派生类中声明一个与基类成员同名的成员，则派生类中的新成员会覆盖基类的同名成员。

基类成员在派生类中的访问属性

子对象：类对象中内嵌的对象
派生类构造函数数据初始化顺序：基类–》派生类中基类子对象–》派生类
多重继承的构造函数：调用基类构造函数顺序是按照声明派生类时基类出现的顺序。

二义性：因为在同一个派生类中存在着两个同名的数据成员，调用时编译器就不知道调用哪一个。
解决方式：
1、声明具体作用域
2、在派生类中声明一个相同名字的数据或函数，进行同名覆盖

虚基类
class 派生类名：virtual 继承方式 基类名

class A
class B: virtual public A
class C: virtual public A
class D: public B, public C

加上virtual 就称为虚基类。D 继承 B , C 时就不会继承两边基类 A 了。

在最后的派生类中要对直接基类和虚基类进行初始化
c++编译系统只执行最后的派生类对虚基类的构造函数的调用，而忽略虚基类的其他派生类（如类B，C）对虚基类的构造函数的调用，这就保证了虚基类的数据成员不会被多次初始化

D(a,b,c):A(a),B(a,b),C(a,c)

基类与派生类的转换
A a1 //定义基类A对象a1
B b1 //定义派生类B对象b1
a1 = b1 //用公用派生类对象对基类对象赋值
A&r = a1 //定义基类A对象的引用r，并用a1对其初始化
A&r = b1 //定义基类A对象的引用r，并用b1对其初始化

用指向基类对象的指针变量指向子类对象是合法的。但只能访问派生类中的基类成员，而不能访问派生类增加的成员

多态性

向不同的对象发送同一个消息，不同的对象在接收时会产生不同的行为。
静态多态性：在编译时系统就能决定调用的是哪个函数（函数重载）
动态多态性：在运行过程中才动态地确定操作所针对的对象（虚函数）
虚函数（virtual）
virtual void fun() ;
虚函数的作用是允许在派生类中重新定义与基类同名的函数，并且可以通过基类指针或引用来访问基类和派生类中的同名函数

虚析构函数：将基类析构函数定义为虚析构函数，这样用基类指针析构时会调用派生类析构函数。当定义基类为虚析构函数时，派生类自动称为虚析构函数

纯虚函数
virtual void fun() = 0;
如果基类只定义函数名，不做函数实现就可定义成纯虚函数。
如果在一个类中声明了纯虚函数，而在其派生类中没有对该函数定义，则该虚函数在派生类中仍然为纯虚函数
包含纯虚函数的类都不能定义对象

抽象类：不用来定义对象而只作为一种基本类型用作继承的类。纯虚函数都是抽象类

“::”是作用域运算符

sizeof与strlen区别

strlen只能计算char*类型，遇到‘\0’停止
sizeof计算大小包括’\0’。

    char dest[] = "aaa";
    cout << sizeof (dest) << endl; //4
    cout << strlen(dest) << endl; //3