C++基础

1. 常量

• 宏常量 #define 常量名 常量值
• 使用const修饰

2. 数据类型

• long long 长长整型，long long b = 3;
• 字符型存储的不是字符，而是对应的ASCII编码；

3. 字符串

• char 变量名[] = "字符串"

char str[] = "hello";

• string 变量名 = “字符串”

string s = "world";

4. bool类型
   占一个字节，true其实就是1， false其实就是0；
5. 数据输入
   cin >> 变量名，对应cout，注意箭头的方向。

int i = 1;
cout << "please input int value: " << endl;
cin >> i;
cout << "i = " << i << endl;

6. 三目运算符
   c = a > b ? a : b;
   三目运算符返回的是变量可以继续赋值；

    int m = 1, n = 2, k = 3;
    m > n ? m : n = 4;
    cout << "m = " << m << " n = " << n << endl;

输出：m = 1 n = 4

7. 函数
   返回值 函数名（参数列表）{ }，和Java还是有些区别，没有访问控制符呢。

#include <iostream>
#include <string>

using namespace std;

void printName(string s);

int main() {
    printName("C++");
    return 0;
}

void printName(string s) {
    cout << "Name is: " << s << endl;
}

上边的例子中我们提前对函数进行了声明（函数声明），函数声明没有函数体。

8. 指针
   指针变量的定义：数据类型 * 指针变量名；

#include<iostream>

using namespace std;

int main() {
    int a = 10;
    int * p;
    p = &a;
    *p = 20;

    cout << "a= " << a << endl;

    return 0;
}

&a是取a的地址，*p是解地址运算符。

9. 常量指针
   const int * p = &a;
   常量指针的指向可以修改，但是指针指向的值不可修改。
   int * const p = &a;
   指针常量的指针的指向不可以修改，但指针指向的值可以修改。
   const int * const p = &a;
   const既修饰指针又修饰常量，指针的指向和指针指向的值都不可修改。
10. 结构体
    struct 结构体名称 {成员列表}

struct Student
{
    string name;
    int age;
    float score;
};

struct Student s1;
s1.name = "lkk";
s1.age = 20;
s1.score = 56.5f;

结构体指针：struct Student * p = &s1;
通过-> 访问结构体变量 p->name = "oi";

11. new操作符
    int * p = new int(10);
    new操作符创建一个整数数据，返回值为该数据类型的指针。
    如果想释放堆区的数据，使用delete，delete p
    释放数组要加[]号，delete [] arr
12. 引用

• 引用就是给变量起别名，语法：数据类型 &引用名称 = 原名；
• int a = 10; int &b = a;
• 引用必须要初始化，比如 int &b; // 错误的
• 引用一旦初始化就不能更改；
  感觉这个引用和Java中的引用不太一样呢。
• 引用做函数参数时，和指针到达的效果一样，同样可以修改原数据的值。
• 如果函数的返回值是一个引用，那这个函数可以作为左值进行使用，比如

int& test()

test() = 20;

• 引用的本质是一个指针常量。
• 常量引用一般用来修饰形参，防止误操作。

13. 默认参数

• 函数的某个参数带默认值，那之后的参数必须都带默认值
• 函数的声明和实现只能有一个带默认值

14. 占位参数
    返回值 函数名（数据类型）{}
    占位参数只有数据类型，没有参数名称。
    占位参数可以有默认参数。
15. 访问权限

• public 公共权限，类外可访问
• protected 子类可访问，其他类不可访问
• private 私有权限，类外不可访问
  struct 和class唯一的区别是默认访问权限不同，struct默认权限是公共权限，class默认权限是私有权限。

16. 构造函数和析构函数
    构造函数和析构函数负责对象的初始化和清理工作，由系统自动调用，空实现。
    构造函数：类名() {}
    析构函数：~类名() {}，析构函数不可以有参数，不可发生重载，对象销毁前系统自动调用。

    Person p1;
    Person p2(5);
    Person p3 = Person(5); 
    Person p4 = 5;

构造函数的调用方式如上。
创建一个类之后，编译器会创建默认构造函数，析构函数和拷贝构造函数。如果提供了有参构造函数，则编译器不在生成默认构造函数。

17. 初始化列表

    Person(int a): _age(a) {

    }

18. 静态成员

• 静态成员在类内声明，在类外初始化

class Person
{
public:
     static int id;
    Person()
    {
        cout << "构造函数" << endl;
    }
    Person(int age) {
        _age = age;
    }

    Person(int a): _age(a) {

    }

    ~Person()
    {
        cout << "析构函数" << endl;
    }

private:
    int _age;
};

int Person::id = 2;

• 静态成员的访问方式有两种，通过对象访问和通过类名访问

Person p(20);
p.id;
或者
Person::id

• 静态成员函数只能访问静态成员变量。
• 静态成员函数也有两种访问方式，Person::func()，p.func()

19. this对象指针

• this是指向当前对象的指针；
• *this是对象本省

20. 友元
    友元的关键字为friend，通过友元可以在类外访问类的私有变量。
    全局函数和类做友元，需要在类的内部进行声明即可。

class A {
      // 全局函数做友元
      friend void fun();
      // 类做友元
      friend class B;
      // 成员函数做友元
      friend void B::test();
}

void fun() {
}

class B {

public:
        void test() {}
}

21. 继承
    语法：class 子类：继承方式 父类。
    继承方式分为：公共继承，保护继承和私有继承。

    
    继承.png
    

    先执行父类的构造函数在执行子类的构造函数，析构函数和构造函数的执行顺序相反。
    如果想访问父类中同名的成员变量，需要加父类的作用域，比如：sun.father::value，成员函数同理，sun.father::fun()
    C++ 允许多重继承，一个子类继承多个父类，语法：class sun: public father1, public father2

22. 菱形继承
    菱形继承会导致数据重复的问题，比如B，C继承A，D继承B，C。
    公共继承前加virtual，变为虚继承，虚继承可以解决数据重复的问题。
    class D：virtual public B，virtual public C {}

23. 多态
    动态多态需要有继承关系，子类重写父类的虚函数。

24. 纯虚函数和抽象类
    纯虚函数的语法：virtual void fun() = 0;
    如果一个类中有纯虚函数，那这个类就是抽象类，抽象类不能实例化，子类必须重写抽象类的纯虚函数，否则也属于抽象类。

25. 虚析构和纯虚析构
    虚析构的语法：virtual ~类名() {}
    纯虚析构的语法：virtual ~类名() = 0
    如果是纯虚析构，则该类属于抽象类，无法实例化对象。

26. 文件
    文件类型分为两类：文本文件和二进制文件
    ofstream 写文件，ifstream 读文件，fstream 读写文件

参考：

1. 黑马培训班的C++教程