C++记录

常用快捷键

CTRL + -向后定位
CTRL + SHIFT + -向前定位

1.注释：CTRL+K+C

2.取消注释：CTRL+K+U

11.调试(启动)：F5

20.查找：CTRL+F

21.替换：CTRL+H

31.跳转到指定的某一行

1)方法1：组合键“Ctrl+G”;

F12 转到定义
CTRL + F12转到声明

定义常量

#define Myddd "wst"     结尾没有冒号

const int a=1;

整型

short  -32768----32767

浮点

float经常加个f在后面。否则会先从double转一次float。

float aa=3.1f;

字符

char a='x';

字符串

string str="xxxx";

需要包含头文件：  #include <string>

布尔

bool flag = true;

goto语句

二维数组

函数的定义和调用

头文件.h，函数的声明

1.函数还有上下的顺序。上面的函数，不能调用下面的函数。。。。     可以先写声明

声明就是没有大括号里面的内容。

2.因为上面的问题。所以需要写.h头文件

class进行分h和cpp：

除了函数体里面的内容，全部分到h里面。包括成员变量。

cpp里面只有函数，类似这样：

void Student::test(int a){

xxxxxx

}

Student::    表示属于这个类的

指针

int *p    这里表示它是指针类型，等号后面的，表示  解引用。

空指针，指向内存地址编号为0的位置，这个不允许访问

野指针，指向了一个不存在的内存地址

常量指针， const int *p;    先是常量，后是指针。指向可以改，指向的值不可以改。

          *p=20; 错误

           p=&b;正确

          const修饰的是*p，也就是值不能改。  如果修饰的p，那么就是指向不能改。

结构体

算是自定义的一个变量类型，内容就是一些已知的变量的组合。

结构体结尾要打分号。类似写了一个变量？

结构体数组：

结构体指针：

通过箭头来直接访问结构体内容

加上const，可以防止误操作：

内存分区，四区

堆区：

用new，可以分配到堆区。但是需要手动释放。

不用new，是在栈区？自动释放？

引用

作用是给变量起个  别名  。

int &a=b;

引用必须初始化，并且初始化后不能改变引用。

引用可以简化用指针的方式进行实参的修改。

引用作为函数的返回值：

int  就是普通的  int* 就是指针类似  int& 就是引用类型

函数也可以作为左值，但是返回的返回值必须是引用。

感觉就是帮忙简写了，先执行函数，然后得到返回值。然后返回值给到一个变量。然后把一个新的值赋值给这个变量。

不能返回局部变量的引用，因为局部变量在栈区，函数执行结束，会被回收。

这里第二次打印，就是错误值：

引用的本质：

指针常量

函数

函数默认参数值

函数占位参数

函数重载:
避免写有默认参数值的情况，否则容易歧义。不要用默认参数。
注意引用的问题。 const也可以作为重载。  传a和传10，传10就是对应const的那个函数。

类

权限：

保护权限和私有，区别是保护权限在继承的情况下，子类可以访问。

struct和class的唯一区别就是： 默认的权限struct为公有，class为私有

析构函数： 函数前面一个波浪线，没有参数

拷贝构造函数：

系统会提供默认的拷贝构造函数，例如
Person p0;

Person p1=Person(p0);

这样会用到默认的拷贝构造函数，会把p0的数据，都复制给p1。值传递，复制的值。

其他类作为本类成员：

其他类先构造，后析构

成员函数：

不属于对象，没有占用对象的内存空间。

它是通过某种方式，来区分不同对象。自己只有一份。

空类：

空类，占用内存是1

this指针：

类默认带有this指针，用它访问成员变量：

this->m_Age

深拷贝、浅拷贝：

我是理解，深拷贝是在内存又新开辟了空间，复制了一样的内容。和原来内容没有联系了。

浅拷贝，直接是一个等号赋值操作？

初始化列表：

另一种构造函数的写法，用单个分号的形式

静态成员变量：

类内声明，类外初始化

通过类名直接访问静态：

Person::m_A

用的是::，不用.

友元：

作用就是打破private的限制，可以访问private的变量和函数

使用friend关键字

全局函数做友元：

把函数声明写到类里面，函数前面加一个friend

运算符重载：

加号运算符重载：

比如Person p=p0+p1;  两个Person相加。默认是不能加的。可以覆写 operator+ 这个函数。来进行重载。

包括成员函数实现和全局函数实现

左移运算符<<重载：

用来打印Person的内容。类似 java的 toString？

函数调用符重载：

也就是()的重载，调用起来很像函数，所以也叫仿函数

继承：

3种继承方式：

public protected private 

父类的private都不能继承。 public原样不变继承。 protected把全部继承为protected。private把全部继承为private。

class Son:public Person{};

查看对象模型，查看占用了多少字节：

继承中构造析构顺序：

父类先构造，后析构

同名成员变量和函数：

默认访问的子类的，访问父类加上作用域

Son s;

int a=s.Person::m_A;

子类同名成员函数，会隐藏父类所有同类成员函数，包括重载的。

要想调用这些父类的函数，需要加作用域。

多继承：

逗号分隔多个父类，访问同名的需要加作用域。

不建议用多继承。

多态：

虚函数：

在继承情况下，重写了同名函数（不是重载）。

要调用到子类的，父类需要改成虚函数

要用引用或者指针才行

传入猫，就调用猫的speak函数。传入狗，就调用狗的speak函数。

多态的原理

虚函数指针，虚函数表

纯虚函数：

在虚函数基础上，加一个  =0 ；

虚析构函数和纯虚析构函数：

文件操作：

写文件：

读文件：

写二进制文件：

读二进制文件：

模板：

函数模板：

就是拿来把重复的函数简化的。比如有多个交换数值的函数，可以是int，可以是double。这里只需要写一个，就可以解决。不用模板，就要写多个交换。  参数用泛型就行了。

定义:

template<typename WST, typename WST1, typename WST2>
WST2 func(WST a, WST1 b,int c) {
}

 func<int ,int ,int>(1, 1,1);

调用方法：

typename 也可以用 class 关键字代替

泛型T，必须要确定出数据类型。否则报错。要么能够推导，要么强制指定。

函数模板如果和普通函数重名，调用规则：

建议不要重名，避免歧义。

比较一些特定的，比如Peson对象，可以具体化模板：

类模板：

和函数模板相似，模板后面跟class 就行

他们也有一些区别：

类模板中的成员函数，并不是一开始就创建，在调用的时候才会创建。

如果父类是模板，子类需要指定T的类型。不想指定，那就把自己也变成模板。

类外实现构造函数或者成员函数，要多加这些：

分文件编写的时候，会出现链接错误（因为类模板的成员函数创建时机是在调用阶段）。需要把h和cpp的文件，合并到.hpp文件里面。

类模板和友元，友元类外实现很麻烦，直接类内实现。

STL：

定义：

标准模板库，提供了容器、算法、迭代器

STL几乎所有代码都采用了模板类和模板函数

迭代器可以基本理解为指针，用来拿数据的，第二种用的多：

仿函数：

定义：

共同体：

类似结构体，但是里面所有变量只有一块内存空间。只有一个值可用？？？给另外一个变量赋值，原来的数据就会被覆盖

这里输出的都是2