C++笔记

目录

C++基础知识

类的一些知识

---

C++基础知识：

1、数字转字符串：str = to_string(num)

2、字符串转整型：num = stoi(str)

注意：stoi的特点是从字符串0位开始截取数字，遇到不是数字的就停止截取，将前面数字部分的转化为整数，如果开头不是数字，则进行stoi会报错invalid_argument。

关于输入cin、cin.get()、getline()

cin、cin.get()、cin.getline()、getline()的区别_啊大1号的博客-CSDN博客_cin getline

3、string的substr用法：

s = “0123456789”

string sub1 = s.substr(5); //只有一个数字5表示从下标为5开始一直到结尾：sub1 = "56789"

string sub2 = s.substr(5, 3); //从下标为5开始截取长度为3位：sub2 = "567"

4、求变量类型  typeif(variable).name()

5、vs操作：按键盘上面的insert可以切换覆盖模式和非覆盖模式

6、strcpy_s(param1, param2, param3);

p1：目标字符串指针

p2：目标地址空间的长度，申请这里的空间是应该为输入字符串的长度+1（如果输入的字符串长度大于该地址空间长度，则不会拷贝，避免了内存溢出）

strlen的长度不包括字符串最后的\0

p3：输入字符串指针

VScode不允许使用strcpy,如果执意要使用，可以加上

#pragma warning(disable:4996)

6.1、在一个新的char*复制多段的char*

char* str1 = "hello world";
char* str2 = "hello cpp";

int len = strlen(str1) + strlen(str2); //strlen不包括'\0'
string str = new char[len+1];
strcpy(str, str1);
strcpy(str+strlen(str1), str2); //这里的地址应该从加入了str1之后的第一个位置开始

//str = "hello worldhello cpp"

7、检查函数声明和函数定义的参数是否对的上

8、尽量不要在头文件中使用using编译命令！

9、static 修饰局部变量时，只会初始化一次，不会再每次调用函数时都初始化该变量

全局变量和全局静态变量的区别

    1）全局变量是不显式用 static 修饰的全局变量，全局变量默认是有外部链接性的，作用域是整个工程，在一个文件内定义的全局变量，在另一个文件中，通过 extern 全局变量名的声明，就可以使用全局变量。
    2）全局静态变量是显式用 static 修饰的全局变量，作用域是声明此变量所在的文件，其他的文件即使用 extern 声明也不能使用。

10、使用命名空间注意：在头文件将结构定义、函数原型放在命名空间时，在实现函数的源文件中也要把函数定义放在命名空间下。在调用这些函数的主函数中，也需要声明使用该命名空间。

11、产生随机数：

包含头文件：#include<ctime>  ;

设置随机数种子：srand(time(0));

产生随机数：

{//产生 [0,b) 范围内到随机数  
  int randomNumber = rand() % b ;
}
{//产生 [a,b) 范围内到随机数
    int randomNumber = a + rand() % ( b -a ) ;
}
{//产生 [0,1] 范围内到随机小数(RAND_MAX需要包含头文件cstdlib)
    double randomNumber =rand() / RAND_MAX
}
{//产生 [0,1) 范围内到随机小数
    double randomNumber =rand() / ( RAND_MAX +1 )
}

{//产生[0, x)的随机数

       rand() * x / RAND_MAX;

}

{//产生[1, 101）

     int randomNumber = rand() % 100 +1;
}

12、count函数:统计区间内字符出现的次数（头文件 #include<algorithm>）

12.1、int num = count(begin, end, 'a');  begin指的是起始地址，end指的是结束地址，第三个参数指的是需要查找的字符。

12.2、A.count(i)来查询在A中值为i的个数

12.3、count_if(begin, end, cmp); cmp需要自己定义，是返回值为bool类型的函数````````````````````````````````````````````````````````````

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

bool comp(int num)
{
    return num%2;
}

int main()
{
    vector <int> V;
    for(int i=1;i<=10;i++)
        V.push_back(i);
    cout<<count_if(V.begin(),V.end(),comp)<<endl;//输出1~10中奇数的个数
    return 0;
}

 转自（C/C++中count函数的使用 - Lorling‘s Blog）

13、显示转换和隐式转换：显示转换类型需要加上想要强制转换的类型，

如double x; int y = (int) x;

隐式转换不需要声明，系统自动进行转换。

14、读写文件的操作：

14.1 写文件 #include<ofstream>

        读文件#include<ifstream>

        读写文件#include<fstream>

14.2 权限：可以被组合使用，中间用 | 隔开；

         其中ofstream默认为out | trunc; ifstream 默认为in fstream 默认为 in | out

ios::in	为输入(读)而打开文件
ios::out	为输出(写)而打开文件
ios::ate	初始位置：文件尾
ios::app	所有输出附加在文件末尾
ios::trunc	如果文件已存在则先删除该文件
ios::binary	二进制方式

 14.3 一些函数

is_open()  判断文件是否打开成功，

14.4  写入文件(从程序写到文件里面)  << 

        读入文件(从文件读取到终端中) >>

14、指针定义了后一定要初始化

15、string 类中有一个将const char*作为参数的构造函数，当使用C-风格的字符串（const char*）来初始化string对象的时候，将自动调用该构造函数。

16、野指针产生的原因：

16.1、指针未初始化（新建的指针不会自动初始化为nullptr）

16.2、 指针越界访问

16.3、 指针释放后未被置空（delete后只把指针指向的内存空间释放了，没有把指针置空）

17、string也有push_back()和pop_back()

18、set,unordered_set删除元素有两种方式：erase(迭代器)或者 erase(elem)删除特定的元素

19、find函数的用法：

    string str1, str2;
    char c;
    str1.find(str2);//从串str1中查找时str2，返回str2中首个字符在str1中的地址
    str1.find(str2,5);//从str1的第5个字符开始查找str2

    str1.find(c);//在str1中查找字符o并返回第一个查找到的地址

    str1.find("str2",2 , 2);//从str1中的第二个字符开始查找of big的前两个字符

//没找到则返回-1

类的一些知识：

类：

1、结构的默认访问权限是public， 而类为private;私有成员变量不可以在类外访问，公有成员变量可以在类外通过作用域解析运算符访问。

2、构造函数：分为无参数（默认）构造函数和有参数的构造函数两种。当两种都存在时，直接使用类名不加参数调用的是默认构造，加了参数会成为有参构造。注意！没有有参构造的时候不要在调用默认构造函数的时候加括号。定义了某种构造函数后，编译器不会再创建默认构造函数，如果需要需人为定义。

3、函数后加const后，表示成员函数隐含传入的this指针为const指针，任何成员函数对类成员的修改都是不被允许的。void Stock::show() const

4、类方法将this指针设置为调用它的对象的地址，*this为对象本身。

5、类对象数组初始化：在数组声明中使用构造函数进行初始化，使用有参的会对数组对应位置进行有参构造初始化，未说明则采用默认构造函数进行初始化。

6、在类中创建一个由所有对象共享的常量： static const int Month = 12;或者（enum ｛int Month = 12｝）该常量将和其他的静态变量存储在一起，被所有的类对象共享

7、含有默认参数的构造函数只有在定义原型的时候加上，定义函数的的时候不用加！

8、局部变量不能作为引用返回。因为局部变量在函数结束时将被删除，引用将指向一个不存在的对象。返回对象可以创建一个副本，将值传递出去。

9、以下四种运算符只能通过成员函数进行重载： =、（）、[ ]、->

10、友元函数：将函数原型放在类内，并在原型声明前加上friend，函数定义的时候不用声明作用域

10.1 这使得该函数成为友元函数，虽然它在类中声明，但不是成员函数，不能用成员运算符 . 来调用；但它与成员函数的访问权限相同。

10.2 因为不是成员函数，所以函数定义的时候不需要加上作用域限定符：：，并且不需要在定义时使用关键字friend

11、类中声明了默认构造函数时，什么都不做也要用大括号声明！

//12、在函数后加const声明，保证函数无法修改调用对象。这一般是针对没有参数的函数而言。

13、转换函数：构造函数只能用于从一种类型转换为类类型。要将类类型转换为某种类型，需要使用转换函数。

用法： operator typename();

注意：转换函数必须为类方法，不能指定返回类型，不能有参数；

14、关键字explicit 用于修饰只有一个关键字的构造函数，该关键字关闭了构造函数的类型隐式转化功能，只能使用显示转化。

15、函数后面加const:  (禁止修改类成员)const的成员函数可以被非const对象和const对象调用，但不加const的成员函数只能被非const对象调用；已定义成const的成员函数，一旦企图修改数据成员的值，则编译器按错误处理

16、静态成员变量：

16.1在类内定义时加static,而在类外声明时不允许加上static（因为这将导致编译器认为该变量为静态全局变量）；

16.2 静态成员变量不在类内初始化

16.3 有特殊情况可以在类内初始化：静态数据成员为const类型或者是枚举类型

17、在构造函数中用new来分配内存时，必须在析构函数中使用delete来释放内存 。如果是用new[]来声明的，则用delete[]来释放。

18、将类作为参数是：两种形式：值传递和地址传递。

值传递实质是将对象的拷贝而不是本身传递给函数，所以会调用构造函数，并且在函数结束后会调用析构函数。值传递意味着创建一个原始变量的副本。

19、拷贝构造函数（复制构造函数）：

原型： Class_name(const Class_name &) 第一个参数是本身类型的引用（可以有多个参数，但其他参数都必须有默认值 ）

19.1 何时调用拷贝构造函数：新建一个对象，并且将这个对象初始化为一个已有对象的时候调用。

例如以下四种情况：（motto是一个已经存在的类对象）

StringBad ditto(motto) 

StringBad metoo = motto 

StringBad also = StringBad(motto)

StringBad *pstring = new StringBad(motto)

还有：

将对象按值传递传递给函数、函数按值返回对象、编译器生成临时对象

19.2 （默认）拷贝构造函数会进行浅拷贝，只拷贝了值，但新对象的值和被拷贝的值指向的是同一块内存，当新对象的内存被释放时，再去释放被拷贝对象将会发生释放一块不存在的内存！这将导致double free,即同一个指针被free两次。

19.3 深度拷贝：在定义拷贝构造函数的时候，给新对象分配一块内存(new)

20、静态成员函数：

20.1、静态成员函数不能被对象调用，但可以通过类名或作用域解析运算符类调用

20.2、静态成员函数不与特定对象相关联，因此只能使用静态数据成员。

21、new和delete

21.1、new和delete需要兼容，new对应delete，new[]对应delete[]

21.2、析构函数只有一个，只能是delete或者delete[]，所以构造函数需要统一为delete或delete[]

22、复制和赋值

赋值：对象已经存在了,再赋值（调用赋值运算符）

复制：新建一个对象的操作（复制会调用复制构造函数）

class Time{
private:
      int hour;
public:
      Time();
        ...
};
Time t1;
Time t2;

//赋值
t1 = t2;

//复制
Time t3(t1);
Time t4 = t1;

 23、返回对象会调用构造函数，但返回引用不会

24、重载<<或>>是，必须返回的是ostream& 或 istream&。因为如果返回的是ostream或istream，会调用拷贝构造函数，但ostream和istream没有公有的拷贝构造函数。

25、定位new运算符：包含头文件new

class Time{
private:
      int hour;
public:
      Time();
        ...
};

int main(){
char *buffer = new char[512];
Time *t1, *t2;

//定位new运算符用法
//两个对象使用空间要预留够，不能有重叠部分。
t1 = new (buffer) Time;
t2 = new (buffer + sizeof(Time));


//delete不能和定位new运算符搭配使用
//buffer是由new[]来创建的，所以需要用delete[]来释放

//此外，定位new运算符需要显式的使用析构函数
t1->~Time();
t2->~Time();

return 0;
}

26、重载<<运算符和>>运算符

ostream& operator<<(ostream& os, const class_name &obj){
    os<<......;
    return os;
}

istream& operator>>(istream& is, classs_name &obj)}
    is>>obj.;
    return is;
}

27、转换函数

//将单个值转换为类类型
class_name(type_name value);

//将类类型转换为某种类型
operator type_name(); //该函数没有返回类型，但是函数内需要返回所需类型的值

28、 重载=运算符

class_name &class_name::operator=(const class_name& cn){
    if(this == &cn){
        return *this;
    }
    delete [] c_pointer;//这里用new[]类型举例
    //为被赋值的对象分配一块空间
    c_pointer = new type_name[size];
    
    //然后将对象cn的成员一一复制给新建的c_pointer
    //注意字符串需要用strcpy_s
    return *this;
}

 29、成员初始化列表：提高构造函数效率，非构造函数不能使用成员初始化列表

Classsy:Classy(int n, int m) : mem1(n), mem2(0), mem3(n*m+2)
{
    //....
}
Classy是一个类，mem1,mem2,mem3是类成员


//继承的使用
Classy的父类是class Father;
Classsy:Classy(int n, int m) : Father(f) 
{
    //....
}
//先调用父类构造函数，再调用复制构造函数，将父类数据成员给子类数据成员赋值

 30、如果没有显示定义，编译器将自动为类提供以下类方法：

默认构造函数、默认析构函数、默认复制构造函数、默认的赋值运算符、默认的地址运算符

31、类中的成员变量char* str的初始化方法

//class.h
class Class_name{
private:
    char* str;
public:
    Class_name();
    //......
}

//class.cpp
Class_name::Class_name(){
    str = new char[1]; //使用这种方式是为了和delete[]兼容
    str[0] = '\0';
}

32、在使用构造函数时，如果想要动态分配内存，想要先删除指针释放空间，再new一块新内存给它，这时候要检查想要释放的指针是否真正被创建了。还有一种方法时在定义的时候将其指定为空指针，这样也能够删除。

33、C++不允许将一种类型的地址/引用赋给另一种类型的指针/指向另一种类型(例外是基类的指针或引用可以对派生类对象进行操作，这类操作被称为向上强制转换(upcasting))

double x = 2.5;
int *pi = &x; //invalid
int &rl = x;  //invalid

34、使用strchr()函数来获取输入的字符是否在需要判断的字符组合内。

cin>>choice;
while(strchr("wstq", choice) == NULL){
    cout<<"Please enter a w, s, t, q:";
    cin>>q;
}
该段代码可以用来检测输入是否符合要求，不符合要求则重新输入，省去很多if的判断

类继承：

1、派生类不能直接访问基类的数据成员，需要通过基类的接口（成员函数）访问

2、派生类构造函数：

2.1、首先创建基类对象

2.2、派生类构造函数应该通过成员初始化列表将基类信息传递给基类构造函数

2.3、派生类构造函数应初始化派生类新增的数据成员

3、创建派生类对象时构造、析构函数顺序

基类构造(初始化继承的成员)--->派生类构造(初始化新增数据成员)--->派生类析构--->基类析构

4、基类指针/基类引用可以不经显示类型转换就指向/引用派生类对象。但指针或引用只能调用基类的方法，不能调用派生类中新增的方法。而反过来，不能将基类的对象和地址赋给派生类的引用和指针。

 5、virtual关键字

定义：虚函数是指一个类中你希望重载的成员函数，当你用一个基类指针或引用指向一个继承类对象的时候，你调用一个虚函数，实际调用的是继承类的版本。

理解为：加了virtual关键字后，编译器会根据对象类型进行判断，再决定调用谁的方法。

5.1、 只要基类的成员函数使用了virtual，则派生类的相同函数将自动成为virtual函数，但为了直观起见还是在派生类中加上virtual关键字。

5.2、函数定义的时候不用加virtual

5.3、如果基类和继承类的析构函数需要执行不同的内容，则需要将析构函数定义为虚析构函数

5.4、虚函数工作原理：编译器给每个对象添加了一个隐藏的成员，成员中保存了一个指向虚函数地址数组的指针(令为vptr)，该数组称为虚函数表(vtbl).

（就是会定义一个隐藏的成员数组来存储所有虚函数的地址）

//基类：Scientist
//派生类：Physicist
//虚函数：void show_all();

Physicist adam(xxx,xxx);
Scientist *psc = &adam;
psc->show_all();
//执行流程：
1.获取psc->vptr地址(派生类的vptr)
2.前往派生类的vtbl
3.获取vtbl中show_all()函数的地址
4.前往该地址，并执行该函数

5.5、虚函数注意事项：

5.5.1、构造函数不能是虚函数

5.5.2、析构函数应当是虚函数

5.5.3、友元不能是虚函数(因为友元不是成员、只有成员函数才能使虚函数)

5.5.4、如果派生类没有对虚函数进行重新定义，那么将使用基类的版本

5.5.5、如果重新定义了继承的方法，应该确保和原来的类型完全相同（如果返回是基类的指针或引用，则可以修改为派生类的指针或引用）

//基类：Scientist
//派生类：Physicist
//虚函数：void show_all();

virtual Scientist & build(int n);

virtual Physicist & build(int n);  //valid

5.5.6、如果基类的虚方法被重载，则派生类应重定义所有的基类版本虚方法

5.6、纯虚函数。在虚函数后面加=0表示该虚函数为纯虚函数。

6、继承类定义的函数里可以直接调用基类的函数，但需要加上基类的作用域解析运算符::

7、将源代码中的函数调用解释为执行特定的函数代码块被称为函数名联编。

7.1、静态联编（早期联编）：在编译过程中进行的联编

7.2、动态联编（晚期联编）：由于虚函数存在，导致编译器在编译时并不知道如何选择代码块。因此编译器必须生成能够在程序运行时选择正确的虚函数方法的代码。

总之，对非虚方法使用静态联编，对虚方法使用动态联编！

8、 protected:public继承可以通过成员函数访问基类的protected权限的成员。对于派生类，保护成员类似于公有成员；对于外部而言，保护成员类似于私有成员。

9、抽象基类ABC(abstract base class):将不同类的共有成员抽象出来成为一个抽象基类，让这些类去继承该ABC。抽象类不会作为对象类型来使用，只用于生成派生类。

9.1、抽象类必须至少使用一个纯虚函数的接口。

9.2、纯虚函数的作用是在基类中为其派生类保留一个函数的名字，以便派生类根据需要对他进行定义。

1、派生类重写基类的虚函数实现多态，要求函数名、参数列表、返回值完全相同。(协变除外)
2、基类中定义了虚函数，在派生类中该函数始终保持虚函数的特性。
3、只有类的非静态成员函数才能定义为虚函数，静态成员函数不能定义为虚函数。
4、如果在类外定义虚函数，只能在声明函数时加virtual关键字，定义时不用加。
5、构造函数不能定义为虚函数，虽然可以将operator=定义为虚函数，但最好不要这么做，使用时容易混淆
6、不要在构造函数和析构函数中调用虚函数，在构造函数和析构函数中，对象是不完整的，可能会出现未定义的行为。
7、最好将基类的析构函数声明为虚函数。(析构函数比较特殊，因为派生类的析构函数跟基类的析构函数名称不一样，但是构成覆盖，这里编译器做了特殊处理)
8、虚表是所有类对象实例共用的虚表剖析。
转自「摩天轮的思念」

10、对于使用了动态分配内存的基类和派生类，派生类的析构函数、复制构造函数和赋值运算符都必须使用相应的基类方法来处理基类元素。

（就是对于使用动态内存分配的派生类的对象使用复制构造、赋值运算符的时候，需要对派生类中基类的成员进行初始化。

具体表现为：派生类的复制构造函数调用时，使用初始化成员列表调用基类复制构造来初始化派生类对象；派生类的赋值运算符在函数内调用基类的赋值运算符来初始化派生类对象）

11、派生类如何使用基类的友元函`数：将派生类型强制转化为基类的类型，再使用。

baseDMA是基类
class baseDMA{
private:
       xxx;
public:
       xxx;
       friend ostream& operator<<(ostream & os, const baseDMA &rs){
        ......;        
       }

};

hasDMA是派生类
class hasDMA{
private:
    xxx;
public:
    friend ostream& operator<<(ostream & os, const hasDMA &hs){
        ......;        
    }
};

hsasDMA的类外定义
ostream& operator<<(ostream & os, const hasDMA &hs){
        os<<(const baseDMA &) hs;  //为了输出基类的成员，需要强制类型转换
        os<<hs.xxx;        
}

12、成员函数属性表

包含和私有继承

1、包含对象成员的类

包含对象成员的类的构造函数初始化对象使用成员初始化列表的时候，和继承基类成员初始化列表有很大不一样。继承基类成员的初始化列表一般是  基类(对象) ，而包含对象成员的类的初始化成员列表采用 对象名(值)的形式。

class Father{
    private:
            int age;
    public:
            explicit Father(int a) { age = a;} //单参数最好加上explict关闭隐式转换，防止误操作
}

class Son : public Father{ //继承自Father类
    private:
            string name; //包含了string类的对象
    public:
            ....;
}

//Son的构造函数
Son(const string% s): name(s){  } //string类对象的初始化
Son(int a): Father(a){}   //Father类的对象的初始化

2、包含多个要初始化的类对象时，用逗号分隔开。而初始化的顺序为类中声明的顺序，而不是初始化成员列表中的顺序。

3、私有继承：基类的私有成员和公有成员都将称为派生类的私有成员。因此派生类无法直接使用基类的私有成员和公有成员方法和数据，只能够通过派生类的成员函数使用。

4、包含和私有继承时调用方法的区别：包含时使用对象来调用方法，私有继承时使用类名和使用作用域解析运算符来调用。

5、派生类访问基类的友元函数，使用显示强制类型转化为基类对象的引用。将派生类对象转化为基类对象。这其中的原理是调用了基类的复制构造函数，并且基类的引用可以指向派生类对象。

6、通常使用包含来建立has-a关系；但如果新类需要访问原有类的保护成员或者需要重新定义虚函数时，则需要使用私有继承。

7、使用using可以重新定义访问权限，在public下使用using声明函数(不用圆括号，函数特征标和返回类型)，让它称为类的公有方法。

 8、MI(mulltiple iheritance) 必须使用public来限定每一个基类，否则没有public限定的将为private继承

9、虚基类：虚基类使得从多个类（这些类的基类相同）派生出的对象只继承一个基类对象；在派生时使用virutal关键字（virtual关键字和权限private、public、proteceted顺序无要求）

10、派生类中的名称优先于直接或间接祖先类中的相同名称

类模板

1、定义类模板：

类模板以以下代码开头：
template<class Type> 

之后的每一个类方法定义时都以以下代码开头：
template<class Type>

例子：Stack类
template<class Type>
class Stack{
    private:
    public:
        Stack();
        bool push(cosnt Type & item);
        Stack & operator=(const Stack& st);(这里可以将Stack<Type> 省略为Stack)
};


构造函数
template<class Type>
Stack<Type>::Stack(){}

普通函数
template<class Type>
bool Stack<Type>::push(cosnt Type & item){}

赋值运算符
Stack<Type> & Stack<Type>::operator=(const Stack<Type>& st){
}

2、模板的具体实现称为实例化或具体化，模板必须和特定的模板实例化请求一起使用，

友元、异常和其他

1、友元类：

定义： friend class XXX;将该定义放在想要被XXX使用该类的成员方法和数据的类中，声明为私有、公有或保护成员都可以。

当一个类和另一个类既不符合is-a关系也不符合has-a关系的时候，采用友元类。

函数需要访问两个类的私有数据，可以在两个类中都将这个函数声明为友元函数。

2、嵌套类使用权限

嵌套在类内的类，将所有成员定义为公有权限。

3、abort()函数：其实现是向标准错误流（即cerr使用的错误流）发送消息abnormal program temination，然后终止程序。返回一个随实现而异的值，告诉操作系统处理失败。

4、try 和 catch 和 throw 

try块标识后关键字try指示，关键字try后面是花括号括起来的代码块，代码块为可能出现异常的代码，若出现异常则进入catch代码块。

catch后面的代码块表示产生异常后所要采取的措施。

throw关键字表示引发异常，紧随其后的字符串或对象指出了异常的特征