C++初阶-CSDN博客

test.cpp

namespace N1

{
 int a;
 int b;
 int Add(int left, int right)
 {
     return left + right;
 }
 namespace N2

 {
     int c;
     int d;
     int Sub(int left, int right)
     {
         return left - right;
     }
 }
}
test.h

namespace N1

{
 int Mul(int left, int right)
 {
     return left * right;
 }
}

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中

2.命名空间使用

命名空间的使用有三种方式：

1.加命名空间名称及作用域限定符

int main()
{
    printf("%d\n", N::a);
    return 0;    
}

2.使用using将命名空间中某个成员引入

using N::b;

int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    return 0;    
}

3.使用using namespace 命名空间名称引入

using namespce N;

int main()
{
    printf("%d\n", N::a);
    printf("%d\n", b);
    Add(10, 20);
    return 0;    
}

二.C++输入&输出

说明：

1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件以及按命名空间使用方法使用std。

2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。

3. 是流插入运算符，>>是流提取运算符。

4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。

C++的输入输出可以自动识别变量类型。

5. 实际上cout和cin分别是ostream和istream类型的对象，>>和也涉及运算符重载等知识，这些知识我们我们后续才会学习，所以我们这里只是简单学习他们的使用。后面我们还有有一个章节更深入的学习IO流用法及原理。注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需包含对应头文件即可，后来将其实现在std命名空间下，为了和C头文件区分，也为了正确使用命名空间，规定C++头文件不带.h；旧编译器(vc 6.0)中还支持格式，后续编译器已不支持，因此推荐使用+std的方式。

#include <iostream>

using namespace std;

三.缺省参数

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。

代码例子

void Func(int a = 0)
{
 cout<<a<<endl;
}

int main()
{
 Func();     // 没有传参时，使用参数的默认值

 Func(10);   // 传参时，使用指定的实参

 
 return 0;
}

缺省参数分类.全缺省参数.半缺省参数

void Func(int a = 10, int b = 20, int c = 30)

void Func(int a, int b = 10, int c = 20)

注意：

1. 半缺省参数必须从右往左依次来给出，不能间隔着给

2. 缺省参数不能在函数声明和定义中同时出现,代码例子

//a.h  
void Func(int a = 10);    
// a.cpp 
void Func(int a = 20)  {}   
// 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那个缺省值。

3. 缺省值必须是常量或者全局变量

4. C语言不支持（编译器不支持）

四. 函数重载

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数或类型或类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。

1、参数类型不同

int Add(int left, int right)
{
 cout << "int Add(int left, int right)" << endl;
 return left + right;
}
double Add(double left, double right)
{
 cout << "double Add(double left, double right)" << endl;
 return left + right;
}

2、参数个数不同

void f()
{
 cout << "f()" << endl;
}

void f(int a)
{
 cout << "f(int a)" << endl;
}

3、参数类型顺序不同

void f(int a, char b)
{
 cout << "f(int a,char b)" << endl;
}

void f(char b, int a)
{
 cout << "f(char b, int a)" << endl;
}

五.引用

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

类型& 引用变量名(对象名) = 引用实体；

注意：引用类型必须和引用实体是同种类型的

1. 引用在定义时必须初始化

2. 一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体

1.常引用

void TestConstRef()
{
    const int a = 10;
    //int& ra = a;   // 该语句编译时会出错，a为常量

    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量

    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同

    const int& rd = d;
}

注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。代码例子

int& Add(int a, int b)
{
    int c = a + b;
    return c;
}
会出错

2.传值、传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

3.引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

4.引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32

位平台下占4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全

小知识点:

&的指向不可以被改变引用做返回值可以提高效率，减少拷贝 &做返回值，返回的内容出作用于必须还存在，静态变量就还在，数组类型的也在

六.内联函数

概念:以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同

一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。

inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

宏的优缺点？

优点：

1.增强代码的复用性。

2.提高性能。

缺点：

1.不方便调试宏。（因为预编译阶段进行了替换） 2.导致代码可读性差，可维护性差，容易误用。 3.没有类型安全的检查。

C++有哪些技术替代宏？

1. 常量定义换用const enum

2. 短小函数定义换用内联函数

七.auto关键字(C++11)

std::mapstd::string, std::string>::iterator it = m.begin();

等价于

auto iterator it=m.begin()

注意：

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto

的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型。

1.auto的使用细则

1. auto与指针和引用结合起来使用用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

2.在同一行定义多个变量当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

八.基于范围的for循环(C++11)

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

注意：范围必须明确

int array[] = { 1, 2, 3, 4, 5 };
 for(auto& e : array)加&可以改变值
     e *= 2;
 
 for(auto e : array)
     cout << e << " ";

与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环。

1.范围for的使用条件

1. for循环迭代的范围必须是确定的对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供

begin和end的方法，begin和end就是for循环迭代的范围。注意：以下代码就有问题，因为for的范围不确定

void TestFor(int array[])
{
    for(auto& e : array)
        cout<< e <<endl;
}

九.空值nullptr

NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。

十.类与对象

1.class与struct

C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。

比如：之前在数据结构初阶中，用C语言方式实现的栈，结构体中只能定义变量；现在以C++方式实现，会发现struct中也可以定义函数。

class默认私有，struct默认公有

2.类的定义

class className

{
  类体：由成员函数和成员变量组成

 
};   一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：

1. 声明和定义全部放在类体中

需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

2. 类声明放在.h文件中,成员函数定义放在.cpp文件中

注意：成员函数名前需要加类名::

①模版的情况下

3.成员变量命名规则的建议：

// 我们看看这个函数，是不是很僵硬？

class Date

{

public:
 void Init(int year)
 {
 // 这里的year到底是成员变量，还是函数形参？

 year = year;
 }

private:
 int year;
};
 所以一般都建议这样
class Date

{

public:
 void Init(int year)
 {
 _year = year;
 }

private:
 int _year;
};

3.类的访问限定符及封装

1 访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。

2.访问限定符说明

1. public修饰的成员在类外可以直接被访问

2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的) 3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

4. 如果后面没有访问限定符，作用域就到 } 即类结束。

5. class的默认访问权限为private，struct为public(因为struct要兼容C)

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

访问限定符在继承中

在继承中pricvate和protected是有很大区别的,private是直接不可见,protected也一样不可以访问，但可以继承,private是都不行,基本用不到，常用的只有

3.C++中struct和class的区别是什么

解答：C++需要兼容C语言，所以C++中struct可以当成结构体使用。另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的类默认访问权限是private。注意：在继承和模板参数列表位置，struct和class也有区别，继承中struct默认是公有，而private是私有继承

4.封装

面向对象的三大特性：封装、继承、多态。

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装本质上是一种管理，让用户更方便使用类。

4.类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 ::

作用域操作符指明成员属于哪个类域。

class Person

{

public:
 void PrintPersonInfo();

private:
 char _name[20];
 char _gender[3];
 int  _age;
};

这里需要指定PrintPersonInfo是属于Person这个类域

void Person::PrintPersonInfo()
{
 cout << _name << " "<< _gender << " " << _age << endl;

5.类的实例化

用类类型创建对象的过程，称为类的实例化

1. 类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；比如：入学时填写的学生信息表，表格就可以看成是一个类，来描述具体学生信息。

2. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

Person类是没有空间的，只有Person类实例化出的对象才有具体的年龄，代码例子

int main()
{
 Person._age = 100;  编译失败：error C2059: 语法错误:“.”
 return 0;
}

3. 做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

6.类对象模型

1 如何计算类对象的大小（结构体内存对齐）

结论：一个类的大小，实际就是该类中”成员变量”之和，当然要注意内存对齐注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

7.this指针

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。

2. 只能在“成员函数”的内部使用

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给

this形参。所以对象中不存储this指针。

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

8.类的6个默认成员函数

如果一个类中什么成员都没有，简称为空类。空类中真的什么都没有吗？并不是，任何类在什么都不写时，编译器会自动生成以下6个默认成员函数。默认成员函数：用户没有显式实现，编译器会生成的成员函数称为默认成员函数。

class Date {};

1.构造函数

构造函数是一个特殊的成员函数，名字与类名相同,创建类类型对象时由编译器自动调用，以保证每个数据成员都有一个合适的初始值，并且在对象整个生命周期内只调用一次。

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。

其特征如下：

1. 函数名与类名相同。

2. 无返回值。

3. 对象实例化时编译器自动调用对应的构造函数。

4. 构造函数可以重载。

// 带参构造函数

Date(int year, int month, int day)
     {
          _year = year;
          _month = month;
          _day = day;
     }

// 无参构造函数

Date()
     {}

//调用

Date d1; // 调用无参构造函数

Date d2(2015, 1, 1); // 调用带参的构造函数

如果类中没有显式定义构造函数，则C++编译器会自动生成一个无参的默认构造函数，一旦用户显式定义编译器将不再生成。

//关于编译器生成的默认成员函数，很多童鞋会有疑惑：不实现构造函数的情况下，编译器会生成默认的构造函数。但是看起来默认构造函数又没什么用？d对象调用了编译器生成的默认构造函数，但是d对象_year/_month/_day，依旧是随机值。也就说在这里编译器生成的默认构造函数并没有什么用？？

内置类型和自定义类型在构造中

解答：C++把类型分成内置类型(基本类型)和自定义类型。内置类型就是语言提供的数据类型，如：int/char...，自定义类型就是我们使用class/struct/union等自己定义的类型，看看下面的程序，就会发现编译器生成默认的构造函数会对自定类型成员_t调用的它的默认成员函数。

lass Time

{

public:
 Time()
 {
 cout << "Time()" << endl;
 _hour = 0;
 _minute = 0;
 _second = 0;
 }

private:
 int _hour;
 int _minute;
 int _second;
};

class Date

{

private:
 // 基本类型(内置类型)

 int _year;
 int _month;
 int _day;
 // 自定义类型

 Time _t;
};

int main()
{
 Date d;
 return 0;
}

注意：内置类型成员变量在类中声明时可以给默认值。

无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。

注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认构造函数。

小知识点:

初始化的两种方式一个构造函数体赋值和初始化列表初始化列表不能检查扩容是否成功，要在{ }z中

2.析构函数

析构函数：与构造函数功能相反，析构函数不是完成对对象本身的销毁，局部对象销毁工作是由编译器完成的。而对象在销毁时会自动调用析构函数，完成对象中资源的清理工作。

析构函数是特殊的成员函数，其特征如下：

1. 析构函数名是在类名前加上字符 ~。

2. 无参数无返回值类型。

3. 一个类只能有一个析构函数。若未显式定义，系统会自动生成默认的析构函数。注意：析构函数不能重载

4. 对象生命周期结束时，C++编译系统系统自动调用析构函数。

内置类型和自定义类型在析构中

关于编译器自动生成的析构函数，是否会完成一些事情呢？下面的程序我们会看到，编译器生成的默认析构函数，对自定类型成员调用它的析构函数。

class Time

{

public:
 ~Time()
 {
 cout << "~Time()" << endl;
 }

private:
 int _hour;
 int _minute;
 int _second;
};

class Date

{

private:
 // 基本类型(内置类型)

 int _year = 1970;
 int _month = 1;
 int _day = 1;
 // 自定义类型

 Time _t;
};

int main()
{
 Date d;
 return 0;
}

程序运行结束后输出：~Time()

在main方法中根本没有直接创建Time类的对象，为什么最后会调用Time类的析构函数？

因为：main方法中创建了Date对象d，而d中包含4个成员变量，其中_year, _month, _day三个是内置类型成员，销毁时不需要资源清理，最后系统直接将其内存回收即可；

而_t是Time类对象，所以在d销毁时，要将其内部包含的Time类的_t对象销毁，所以要调用Time类的析构函数。

但是：main函数中不能直接调用Time类的析构函数，实际要释放的是Date类对象，所以编译器会调用Date类的析构函数，而Date没有显式提供，则编译器会给Date类生成一个默认的析构函数，目的是在其内部调用Time类的析构函数，即当Date对象销毁时，要保证其内部每个自定义对象都可以正确销毁main函数中并没有直接调用Time类析构函数，而是显式调用编译器为Date类生成的默认析构函数

注意：创建哪个类的对象则调用该类的析构函数，销毁那个类的对象则调用该类的析构函数

如果类中没有申请资源时，析构函数可以不写，直接使用编译器生成的默认析构函数，比如

Date类；有资源申请时，一定要写，否则会造成资源泄漏，比如Stack类。

小知识点：析构顺序

设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？（）

C c;

int main()

{

A a;

B b;

static D d;

return 0；

}

分析:1、类的析构函数调用一般按照构造函数调用的相反顺序进行调用，但是要注意static对象的存在，因为static改变了对象的生存作用域，需要等待程序结束时才会析构释放对象

a,b是局部对象，而且遵循先创建的后销毁的原则

2、全局对象先于局部对象进行构造

3、局部对象按照出现的顺序进行构造，无论是否为static

4、所以构造的顺序为 c a b d

5、析构的顺序按照构造的相反顺序析构，只需注意static改变对象的生存作用域之后，会放在局部对象之后进行析构

6、因此析构顺序为B A D C

析构顺序和次数

1：设已经有A,B,C,D4个类的定义，程序中A,B,C,D析构函数调用顺序为？（）

C c;

void main()

{

A*pa=new A();

B b;

static D d;

delete pa;

}分析:首先手动释放pa，所以会先调用A的析构函数，其次会跟定义相反的顺序释放局部对象，这里只有b，就释放b，再释放静态局部对象d，再释放全局对象c

2：以下代码中，A 的构造函数和析构函数分别执行了几次： (10,10 )

A*pa=new A[10];

delete []pa;

A.申请数组空间，构造函数调用的次数就是数组的大小

B.正确

C.申请数组空间，构造函数调用的次数就是数组的大小

D.如果释放数组空间，delete使用了[]，则会对应的调用数组大小次数的析构函数

3.拷贝构造函数

那在创建对象时，可否创建一个与已存在对象一某一样的新对象呢？

拷贝构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

拷贝构造函数也是特殊的成员函数，其特征如下：

1. 拷贝构造函数是构造函数的一个重载形式。

2. 拷贝构造函数的参数只有一个且必须是类类型对象的引用，使用传值方式编译器直接报错，因为会引发无穷递归调用。

Date(int year = 1900, int month = 1, int day = 1)
 {
 _year = year;
 _month = month;
 _day = day;
 }
 // Date(const Date& d)   // 正确写法

    Date(const Date d)   // 错误写法：编译报错，会引发无穷递归

 {
 _year = d._year;
 _month = d._month;
 _day = d._day;
}

内置类型和自定义类型在拷贝构造

若未显式定义，编译器会生成默认的拷贝构造函数。默认的拷贝构造函数对象按内存存储按字节序完成拷贝，这种拷贝叫做浅拷贝，或者值拷贝。

注意：在编译器生成的默认拷贝构造函数中，内置类型是按照字节方式直接拷贝的，而自定义类型是调用其拷贝构造函数完成拷贝的。

注意：类中如果没有涉及资源申请时，拷贝构造函数是否写都可以；一旦涉及到资源申请时，则拷贝构造函数是一定要写的，否则就是浅拷贝。

拷贝构造函数典型调用场景：使用已存在对象创建新对象函数参数类型为类类型对象函数返回值类型为类类型对象.

为了提高程序效率，一般对象传参时，尽量使用引用类型，返回时根据实际场景，能用引用尽量使用引用。

9.赋值运算符重载

运算符重载

返回*this

Date& operator=(const Date& d)
 {
 if(this != &d)
       {
            _year = d._year;
            _month = d._month;
            _day = d._day;
       }
        
        return *this;
 }

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。函数名字为：关键字operator后面接需要重载的运算符符号。函数原型：返回值类型operator操作符(参数列表)

注意：

不能通过连接其他符号来创建新的操作符：比如operator@

重载操作符必须有一个类类型参数

用于内置类型的运算符，其含义不能改变，例如：内置的整型+，不能改变其含义

作为类成员函数重载时，其形参看起来比操作数数目少1，因为成员函数的第一个参数为隐藏的this

.* :: sizeof ?: . 注意以上5个运算符不能重载。这个经常在笔试选择题中出现。

全局的operator==

这里会发现运算符重载成全局的就需要成员变量是公有的，那么问题来了，封装性如何保证？

这里其实可以用我们后面学习的友元解决，或者干脆重载成成员函数。

bool operator==(const Date& d1, const Date& d2)
{
    return d1._year == d2._year

   && d1._month == d2._month

        && d1._day == d2._day;
}

类内的operator==

 //bool operator==(Date* this, const Date& d2)

    // 这里需要注意的是，左操作数是this，指向调用函数的对象

    bool operator==(const Date& d2)
 {
        return _year == d2._year;
            && _month == d2._month

            && _day == d2._day;

赋值运算符重载

赋值运算符重载格式参数类型：const T&，传递引用可以提高传参效率

返回值类型：T&，返回引用可以提高返回的效率，有返回值目的是为了支持连续赋值

检测是否自己给自己赋值返回*this ：要复合连续赋值的含义

注意:赋值运算符只能重载成类的成员函数不能重载成全局函数,赋值运算符重载成全局函数，注意重载成全局函数时没有this指针了，需要给两个参数,“operator =”必须是非静态成员

内置类型和自定义类型在赋值运算符重载

用户没有显式实现时，编译器会生成一个默认赋值运算符重载，以值的方式逐字节拷贝。注意：内置类型成员变量是直接赋值的，而自定义类型成员变量需要调用对应类的赋值运算符重载完成赋值。

小知识点:

两个已经存在的对象赋值才是赋值拷贝构造是一个存在一个不存在

日期类的实现(已经弄完了)

10.初始化列表

虽然上述构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。

注意】

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)

2. 类中包含以下成员，必须放在初始化列表位置进行初始化：

引用成员变量

const成员变量

自定义类型成员(且该类没有默认构造函数时)

class A

{

public:
 A(int a)
 :_a(a)
 {}

private:
 int _a;
};
 

class B

{

public:
 B(int a, int ref)
 :_aobj(a)
 ,_ref(ref)
 ,_n(10)
 {}

private:
 A _aobj; // 没有默认构造函数

 int& _ref; // 引用

 const int _n; // const 

};

尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

小知识点:

初始化的两种方式一个构造函数体赋值和初始化列表初始化列表不能检查扩容是否成功，要在{ }z中

11.static成员，explicit关键字

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问

4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

小知识点:

概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化

特性

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区

2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明

3. 类静态成员即可用类名::静态成员或者对象.静态成员来访问

4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员

5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制

知识点：

局部的静态成员，不会在main之前初始化，全局的在mian之前就会调用默认构造

自定义传参要调用拷贝构造

多次调用静态，也只会创建一次

private中，有成员变量（属于每个类对象，储存在对象里）

静态成员变量（属于类，属于类的每个对象，存储在静态区，生命周期是全局的）

静态成员变量不能在private中直接赋值

静态成员变量的初始化，必须在类外定义（可已突破私有）

静态成员变量一般配套静态成员函数

非静态可以调用静态

静态成员函数不能访问非静态成员变量，因为无this指针

全局变量的缺点，任何地方都可以进行修改

例题：1+2+3+4+5+...+n不能用for，while求1+2+3+...+n_牛客题霸_牛客网 (nowcoder.com)

全局对象和静态对象，出了作用于还在（静态区）任何类型的指针都是内置类型

赋值运算符不能重载成全局的默认成员函数都不能写到全局

全局的静态成员会在进入main之前就初始化局部的相反静态成员调用多次，只创建一次和内联函数的作用类似静态成员变量存储在静态区，生命周期是全局的静态成员初始化必须在类外，定义时可以突破私有静态成员函数不能访问非静态成员变量，无this指针

12this指针

this指针不能在形参或者实参的位置显示

传值返回，返回的是他的拷贝，所以要调用一次拷贝构造

传引用返回，返回的是他的别名

this指针的特性

1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。

2. 只能在“成员函数”的内部使用

3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给

this形参。所以对象中不存储this指针。

4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递

this的定义

const指向this，this不能改，指向的可以改，const Dat*this/Dat const*this，指向的不可以改

this在哪里

this是形参，所以this指针跟普通函数一样存在函数调用的栈帧里面

空间没有消失

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”

的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

就是调用这个函数的时候得保证当前调用函数的这个对象是存在的这里肯定是没销毁的因为返回的是当前对象本身

传值返回，返回的是他的拷贝，所以要调用一次拷贝构造

传引用返回，返回的是他的别名

a.静态成员函数没有this指针，只有非静态成员函数才有，且为隐藏指针

B.非静态成员函数的第一个参数就是隐藏的this指针

C.this指针在非静态的成员函数里面，对象不存在，故错误

D.单纯的对this赋空是不可以的，不过可以强转直接赋空，不过一般不进行这样的操作

13.友元函数和友元类(Date里有)

问题：现在尝试去重载operator，然后发现没办法将operator重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同理

元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。

class Date

{
 friend ostream& operator<<(ostream& _cout, const Date& d);
 friend istream& operator>>(istream& _cin, Date& d);

public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
 

private:
int _year;
 int _month;
 int _day;
};
 

ostream& operator<<(ostream& _cout, const Date& d)
{
 _cout << d._year << "-" << d._month << "-" << d._day;
 return _cout;
}
 

istream& operator>>(istream& _cin, Date& d)
{
 _cin >> d._year;
 _cin >> d._month;
 _cin >> d._day;
 return _cin;
}
 

int main()
{
 Date d;
 cin >> d;
 cout << d << endl;
 return 0;
}

说明:

友元函数可访问类的私有和保护成员，但不是类的成员函数

友元函数不能用const修饰

友元函数可以在类定义的任何地方声明，不受类访问限定符限制

一个函数可以是多个类的友元函数

友元函数的调用与普通函数的调用原理相同

友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。

友元关系是单向的，不具有交换性

比如上述Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。

友元关系不能传递如果B是A的友元，C是B的友元，则不能说明C时A的友元。

友元关系不能继承

一个类的友元函数能够访问类的( )

A.私有成员

B.保护成员

C.公有成员

D.所有成员

A.可以访问，这也把一个函数声明为友元的目的

B.可以访问

C.可以访问

D.友元函数对一个类里面的所有成员，全部通吃，正确

A.友元函数不是类的成员函数，就相当于你的朋友再亲密也不是你的家人，既然不是类成员函数，那和普通成员函数调用一样，不需要通过对象调用

B.友元的目的就是为了访问类的私有数据，成员函数可以直接访问类的私有数据

C.类的成员函数属于类，调用时其内部数据会通过this指针来调用

D.友元函数不具备this指针，更谈不上通过this调用，故错误

全局函数不具备this指针

B.static函数不具备this指针

C.友元函数不具备this指针

D.正确，普通成员方法具有隐藏的this指针

十一.内存管理

函数参数使用的空间是在（）中申请的，malloc或new是在（）中申请空间的？（）

答

A.参数在栈空间存放，malloc或new申请的空间为堆区

B.正确

C.参数在栈空间存放，malloc或new申请的空间为堆区

D.参数在栈空间存放，malloc或new申请的空间为堆区

【说明】

1. 栈又叫堆栈--非静态局部变量/函数参数/返回值等等，栈是向下增长的。

2. 内存映射段是高效的I/O映射方式，用于装载一个共享的动态内存库。用户可使用系统接口创建共享共享内存，做进程间通信。（Linux课程如果没学到这块，现在只需要了解一下）

3. 堆用于程序运行时动态内存分配，堆是可以上增长的。

4. 数据段--存储全局数据和静态数据。 5. 代码段--可执行的代码/只读常量。

new int[3]{1,2,3};开空间加初始化

new是操作符
”abcd”是常量字符串，不可修改，在常量区

C语言中动态内存管理方式：malloc/calloc/realloc/free

void Test ()
{
 int* p1 = (int*) malloc(sizeof(int));
 free(p1);
 
 // 1.malloc/calloc/realloc的区别是什么？

 int* p2 = (int*)calloc(4, sizeof (int));
 int* p3 = (int*)realloc(p2, sizeof(int)*10);
 
 // 这里需要free(p2)吗？

 free(p3 );
}

C++内存管理方式

C语言内存管理方式在C++中可以继续使用，但有些地方就无能为力，而且使用起来比较麻烦，因此C++又提出了自己的内存管理方式：通过new和delete操作符进行动态内存管理。

new/delete操作内置类型

void Test()
{
 // 动态申请一个int类型的空间

 int* ptr4 = new int;
 
 // 动态申请一个int类型的空间并初始化为10

 int* ptr5 = new int(10);
 
 // 动态申请10个int类型的空间

 int* ptr6 = new int[10];
 
 delete ptr4;
 delete ptr5;
 delete[] ptr6;
}

new和delete操作自定义类型

class A

{

public:
 A(int a = 0)
 : _a(a)
 {
 cout << "A():" << this << endl;
 }
 
 ~A()
 {
 cout << "~A():" << this << endl;
 }
 

private:
 int _a;
};
 

int main()
{
 // new/delete 和 malloc/free最大区别是 new/delete对于【自定义类型】除了开空间还会调用构
造函数和析构函数

 A* p1 = (A*)malloc(sizeof(A));
 A* p2 = new A(1);
 free(p1);
 delete p2;
 
 // 内置类型是几乎是一样的

 int* p3 = (int*)malloc(sizeof(int)); // C

     int* p4 = new int;
     free(p3);
     delete p4;
 
     A* p5 = (A*)malloc(sizeof(A)*10);
     A* p6 = new A[10];
     free(p5);
     delete[] p6;
 
     return 0;
}

注意：在申请自定义类型的空间时，new会调用构造函数，delete会调用析构函数，而malloc与free不会。

operator new与operator delete函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过operator delete全局函数来释放空间。

/*
operator new：该函数实际通过malloc来申请空间，当malloc申请空间成功时直接返回；申请空间失败，
尝试执行空 间不足应对措施，如果改应对措施用户设置了，则继续申请，否则抛异常。

*/

void *__CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
 // try to allocate size bytes

 void *p;
 while ((p = malloc(size)) == 0)
 if (_callnewh(size) == 0)
 {
 // report no memory

 // 如果申请内存失败了，这里会抛出bad_alloc 类型异常

 static const std::bad_alloc nomem;
 _RAISE(nomem);
 }
 
 return (p);
}
 

/*
operator delete: 该函数最终是通过free来释放空间的

*/

void operator delete(void *pUserData)
{
 _CrtMemBlockHeader * pHead;
 
 RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
if (pUserData == NULL)
 return;
 
 _mlock(_HEAP_LOCK); /* block other threads */

 __TRY

 
 /* get a pointer to memory block header */

 pHead = pHdr(pUserData);
 
 /* verify block type */

 _ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
 
 _free_dbg( pUserData, pHead->nBlockUse );
 
 __FINALLY

 _munlock(_HEAP_LOCK); /* release other threads */

 __END_TRY_FINALLY

 
 return;
}
 

/*
free的实现

*/

#define free(p) _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道，operator new 实际也是通过malloc来申请空间，如果malloc申请空间成功就直接返回，否则执行用户提供的空间不足应对措施，如果用户提供该措施就继续申请，否则就抛异常。operator delete 最终是通过free来释放空间的。

new和delete的实现原理

内置类型

如果申请的是内置类型的空，new和malloc，delete和free基本类似，不同的地方是：new/delete申请和释放的是单个元素的空间，new[]和delete[]申请的是连续空间，而且new在申请空间失败时会抛异常，malloc会返回NULL。

自定义类型

new的原理

1. 调用operator new函数申请空间

2. 在申请的空间上执行构造函数，完成对象的构造

delete的原理

1. 在空间上执行析构函数，完成对象中资源的清理工作

2. 调用operator delete函数释放对象的空间

new T[N]的原理

1. 调用operator new[]函数，在operator new[]中实际调用operator new函数完成N个对象空间的申请

2. 在申请的空间上执行N次构造函数

delete[]的原理

1. 在释放的对象空间上执行N次析构函数，完成N个对象中资源的清理

2. 调用operator delete[]释放空间，实际在operator delete[]中调用operator delete来释放空间

定位new表达式(placement-new) （了解）

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。使用格式：

new (place_address) type或者new (place_address) type(initializer-list) place_address必须是一个指针，initializer-list是类型的初始化列表使用场景：定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，需要使用new的定义表达式进行显示调构造函数进行初始化。

class A

{

public:
 A(int a = 0)
 : _a(a)
 {
 cout << "A():" << this << endl;
 }
 
 ~A()
 {
 cout << "~A():" << this << endl;
 }
 

private:
 int _a;
};
 

// 定位new/replacement new

int main()
{
 // p1现在指向的只不过是与A对象相同大小的一段空间，还不能算是一个对象，因为构造函数没有执行

 A* p1 = (A*)malloc(sizeof(A));
 new(p1)A; // 注意：如果A类的构造函数有参数时，此处需要传参

 p1->~A();
 free(p1);
 
 
 A* p2 = (A*)operator new(sizeof(A));
 new(p2)A(10);
 p2->~A();
 operator delete(p2);
  return 0;
}

malloc/free和new/delete的区别

malloc/free和new/delete的共同点是：都是从堆上申请空间，并且需要用户手动释放。不同的地方是：

1. malloc和free是函数，new和delete是操作符

2. malloc申请的空间不会初始化，new可以初始化

3. malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可，如果是多个对象，[]中指定对象个数即可

4. malloc的返回值为void*, 在使用时必须强转，new不需要，因为new后跟的是空间的类型

5. malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需要捕获异常

6. 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成空间中资源的清理

内存泄漏

什么是内存泄漏，内存泄漏的危害

什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

void MemoryLeaks()
 {
 // 1.内存申请了忘记释放

 int* p1 = (int*)malloc(sizeof(int));
 int* p2 = new int;
 
 // 2.异常安全问题

 int* p3 = new int[10];
 
 Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.

 
 delete[] p3;
 }

内存泄漏分类（了解）

C/C++程序中一般我们关心两种方面的内存泄漏：堆内存泄漏(Heap leak)、

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。系统资源泄漏指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。

2. 采用RAII思想或者智能指针来管理资源。

3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。总结一下:

内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

小知识点new和delete【】匿名对象和重复释放

malloc realloc calloc free

new delete

new[] delete[]

要匹配使用

匿名对象创建完，立刻销毁

例题：

1：ClassA *pclassa=new ClassA[5];//调用5次构造函数，new[]的连续的

delete pclassa;这里相当于只是将第一个对象释放

c++语言中，类ClassA的构造函数和析构函数的执行次数分别为( )，会崩溃

解答：

A.申请对象数组，会调用构造函数5次，delete由于没有使用[]，此时只会调用一次析构函数，但往往会引发程序崩溃

B.构造函数会调用5次

C.析构函数此时只会调用1次，要想完整释放数组空间，需要使用[]

注意：如果一个类定义了析构函数，再使用new[]申请对象时，编译器会多申请四个字节，用来存放对象个数

2：使用 char* p = new char[100]申请一段内存，然后使用delete p释放，有什么问题？( )

答：A.对于内置类型，此时delete就相当于free，因此不会造成内存泄漏

B.正确

C.编译不会报错，建议针对数组释放使用delete[],如果是自定义类型，不使用方括号就会运行时错误

D.对于内置类型，程序不会崩溃，但不建议这样使用

3：class A{ int i; };

class B{

A *p; public: B(){p=new A;} ~B(){delete p;}

};

void sayHello(B b){ } i

nt main()

{ B b;

sayHello(b); }

答：
会重复释放
因为参数b是浅拷贝main函数中的b，所以两个对象销毁的时候都是执行delete p
重复释放会导致程序崩溃

A.new会申请空间，同时调用构造函数初始化对象，malloc只做一件事就是申请空间

B.new/delete与malloc/free最大区别就在于是否会调用构造函数与析构函数

C.需要头文件malloc.h,只是平时这个头文件已经被其他头文件所包含了，用的时候很少单独引入，故错误

D.new是操作符，malloc是函数

十二.函数模版和类模版

函数模板

函数模板概念

函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本

函数模板格式

.1 函数模板格式

template<typename T1, typename T2,......,typename Tn>

返回值类型函数名(参数列表){}

template<typename T>
 void Swap( T& left,  T& right) 
{    T temp = left;   
     left = right;

     right = temp;
}

注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

函数模板的实例化

用不同类型的参数使用函数模板时，称为函数模板的实例化。模板参数实例化分为：隐式实例化和显式实例化。

1. 隐式实例化：让编译器根据实参推演模板参数的实际类型(用int强转)

template<class T>
 T Add(const T& left, const T& right)
 {
    return left + right;
 }
 int main()
 {
    int a1 = 10, a2 = 20;
    double d1 = 10.0, d2 = 20.0;
    Add(a1, a2);
    Add(d1, d2);


该语句不能通过编译，因为在编译期间，当编译器看到该实例化时，需要推演其实参类型  
通过实参a1将T推演为int，通过实参d1将T推演为double类型，但模板参数列表中只有一个T，     
编译器无法确定此处到底该将T确定为int 或者 double类型而报错
注意：在模板中，编译器一般不会进行类型转换操作，因为一旦转化出问题，编译器就需要背黑锅    
    Add(a1, d1);  
// 此时有两种处理方式：1. 用户自己来强制转化 2. 使用显式实例化
    Add(a1, (int)d1);
   return 0;
}

显式实例化：在函数名后的<>中指定模板参数的实际类型

int main(void)
 {
    int a = 10;
    double b = 20.0;
    
    // 显式实例化
    Add<int>(a, b);
    return 0;
 }

如果类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错。

重要例子

错误示例：

template<class T>
T add(T&left,T&right)
{
    return left+right;
}
int main()
{
    int a=1;
    double b=2.0;
    add(a,(int)b);   
}

这里面的b会传不过去，因为强制类型转换会产生临时变量（有常性），不可修改所以要在接收b处加一个const

注意：由于参数类型不一样，模板不支持类型转换，推导参数会产生二义性，编译错误

类模版

类模板的定义格式

template<class T1, class T2, ..., class Tn> 

class 类模板名

{
 // 类内成员定义

};

动态顺序表

注意：Vector不是具体的类，是编译器根据被实例化的类型生成具体类的模具

template<class T>

class Vector

{ 

public :
 Vector(size_t capacity = 10)
 : _pData(new T[capacity])
 , _size(0)
 , _capacity(capacity)
 {}
 
 // 使用析构函数演示：在类中声明，在类外定义。

 ~Vector();
 
 void PushBack(const T& data)；

 void PopBack()；

 // ...

 
 size_t Size() {return _size;}
 
 T& operator[](size_t pos)
{
 assert(pos < _size);
 return _pData[pos];
 }
 

private:
 T* _pData;
 size_t _size;
 size_t _capacity;
};

注意：类模板中函数放在类外进行定义时，需要加模板参数列表

template <class T>

Vector<T>::~Vector()
{
 if(_pData)
 delete[] _pData;
 _size = _capacity = 0;
}

类模板的实例化

类模板实例化与函数模板实例化不同，类模板实例化需要在类模板名字后跟<>，然后将实例化的类型放在<>中即可，类模板名字不是真正的类，而实例化的结果才是真正的类。

Vector类名，Vector<int>才是类型 
Vector<int> s1; 
Vector<double> s2;

十三.string vector list stack queue priority_queue 反向迭代器

模拟实现中几乎都有，这里补充一下

函数模板特化

函数模板的特化步骤：

1. 必须要先有一个基础的函数模板

2. 关键字template后面接一对空的尖括号<>

3. 函数名后跟一对尖括号，尖括号中指定需要特化的类型

4. 函数形参表: 必须要和模板函数的基础参数类型完全相同，如果不同编译器可能会报一些奇怪的错误。

// 函数模板 -- 参数匹配

template<class T>

bool Less(T left, T right)
{
 return left < right;
}
 

// 对Less函数模板进行特化

template<>

bool Less<Date*>(Date* left, Date* right)
{
    return *left < *right;
}
 

int main()
{
 cout << Less(1, 2) << endl;
 
 Date d1(2022, 7, 7);
 Date d2(2022, 7, 8);
 cout << Less(d1, d2) << endl;
 
 Date* p1 = &d1;
 Date* p2 = &d2;
 cout << Less(p1, p2) << endl; // 调用特化之后的版本，而不走模板生成了

 return 0;
}

注意：一般情况下如果函数模板遇到不能处理或者处理有误的类型，为了实现简单通常都是将该函数直接给出。

bool Less(Date* left, Date* right)
{
 return *left < *right;
}

类模板特化

全特化

template<class T1, class T2> 

class Data

{

public:
 Data() {cout<<"Data<T1, T2>" <<endl;}

private:
 T1 _d1;
 T2 _d2;
};
 

template<> 

class Data<int, char>

{

public:
 Data() {cout<<"Data<int, char>" <<endl;}

private:
 int _d1;
 char _d2;
};
 

void TestVector()
{
 Data<int, int> d1;
 Data<int, char> d2;
}

偏特化

template<class T1, class T2> 

class Data

{

public:
 Data() {cout<<"Data<T1, T2>" <<endl;}

private:
 T1 _d1;
 T2 _d2;
};

偏特化有以下两种表现方式：部分特化将模板参数类表中的一部分参数特化。

两个参数偏特化为指针类型

template <typename T1, typename T2> 

class Data <T1*, T2*> 
{ 

public:
 Data() {cout<<"Data<T1*, T2*>" <<endl;}

两个参数偏特化为引用类型

template <typename T1, typename T2>
class Data <T1&, T2&>

模板的分离编译

// a.h

template<class T>

T Add(const T& left, const T& right);
// a.cpp
template<class T>

T Add(const T& left, const T& right)
{
 return left + right;
}
 

// main.cpp

#include"a.h"

int main()
{
 Add(1, 2);
 Add(1.0, 2.0);
 
 return 0;
}

解决方法

1. 将声明和定义放到一个文件 "xxx.hpp" 里面或者xxx.h其实也是可以的。推荐使用这种。

2. 模板定义的位置显式实例化。这种方法不实用，不推荐使用。

模板总结

优点

1. 模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生

2. 增强了代码的灵活性【缺陷】

1. 模板会导致代码膨胀问题，也会导致编译时间变长

2. 出现模板编译错误时，错误信息非常凌乱，不易定位错误

知识点总结(易遗漏):

临时对象具有常性函数返回的值具有常性隐式类型转换也有常性，因为转换的过程，需要创建临时变量

全特化和偏特化和仿函数在(优先级队列的模拟实现中)

优先级队列priority_queue底层采用vector容器作为底层数据结构

优先级队列默认情况为：大堆

priority_queue<int, vector<int>, greater<int> > c; //c指定了比较规则，是小堆

vector、deque底层都是用了连续空间，所以虽然++iter迭代器了，但是erase(tempit)以后

底层是连续空间，删除会挪动数据，最终导致iter意义变了，已失效了。

而list，不是连续空间，删除以后tempIt虽然失效了，但是不影响iter。

list不支持随机访问不支持[ ]，空间不连续

list,erase(it)删除节点后，只有指向当前节点的迭代器失效了，其前后的迭代器仍然有效，因为底层为不连续空间，只有被删除的节点才会失效

list的insert后不影响什么。而vector的insert会影响扩容，所以vector用完insert后就不能再使用其返回的地址了，可能已经失效了

如果需要高效的随机存取，还要大量的首尾的插入删除则建议使用deque,deque底层总体为不连续空间

vector底层是以当前类型的指针作为迭代器，对于指针而言，能够进行操作的方法都支持，如==,++,*，而>>运算符并没有重载

at() 和 operator[] 都是根据下标获取任意位置元素的，在debug模式下两者都会去做边界检查。

当发生越界行为时，at 是抛异常，operator[] 内部的assert会触发

vector容量满时，一般会以容量的2倍扩充容量，这是为了减少扩容的次数，减少内存碎片

vector<int> v(ar, ar+n);

cout<<v.size()<<":"<<v.capacity()<<endl; //大小为数组元素个数，因此size=10 capacity=10

v.reserve(100); //预留空间100

v.resize(20); //调整元素为20个，此时元素的size会改变，由于个数小于容量，因此容量不会变小v.reserve(50);//期望预留空间为50，可是现在的空间已经有100个，所以空间不会减小v.resize(5); //元素个数调整为5

A.如果想大量随机读取数据操作，vector是首选的容器

B.如果想大量的插入和删除数据，list效率较高，是首选

C.由于vector底层是连续空间，其迭代器就是相应类型的指针，所以支持对应的操作

D.list迭代器不支持[]运算符

A.vector在尾部插入数据不需要移动数据，list为双向循环链表也很容易找到尾部，因此两者在尾部插入数据效率相同

B.vector头部插入效率极其低，需要移动大量数据

C.vector由于在头部插入数据效率很低，所以没有提供push_front方法

D.list不支持随机访问

A.如果想大量随机读取数据操作，vector是首选的容器

B.如果想大量的插入和删除数据，list效率较高，是首选

C.由于vector底层是连续空间，其迭代器就是相应类型的指针，所以支持对应的操作

D.list迭代器不支持[]运算符

A.vector的插入操作如果导致底层空间重新开辟，则迭代器就会失效。如果空间足够，不扩容时，迭代器不一定失效，比如push_back尾插，元素插入到空间末尾，在不扩容时不会对迭代器产生影响

C.vector删除，当前元素肯定失效，后面元素会牵扯到移动数据，因此删除元素后面的迭代器也会失效

D. vector的删除操作不光会导致指向被删除元素的迭代器失效，删除元素后面的迭代器也会失效

vector<int>v(10,1)；

算法sort(v.begin()，v.end(),greater<int>())；优先级队列模拟实现中而模版中是类型是template<class T,class Ref,class greater> 不用带括号，不过优先级队列默认是less,大堆

it = mylist.erase(it);,erase后需要接受一下返回值，要不然当前的it就失效了

c_str

例题：

int main(int argc, char *argv[])

{

string a="hello world";

string b=a;

if (a.c_str()==b.c_str())

{

cout<<"true"<<endl;

}

else cout<<"false"<<endl;

string c=b;

c="";

if (a.c_str()==b.c_str())

{

cout<<"true"<<endl;

}

else cout<<"false"<<endl;

a="";

if (a.c_str()==b.c_str())

{

cout<<"true"<<endl;

}

else cout<<"false"<<endl;

return 0;

}

答：a 和 b的值虽然相同，但是a.c_str()==b.c_str()比较的是存储字符串位置的地址，a和b是两个不同的对象，内部数据存储的位置也不相同，因此不相等，后面c="",a=""与b对象都没有任何的影响，所以都不相等

仿函数

A.仿函数是模板函数，可以根据不同的类型代表不同的状态

B.仿函数是模板函数，可以有不同类型

C.仿函数是模板函数，其速度比一般函数要慢,故错误

D.仿函数在一定程度上使代码更通用，本质上简化了代码

C++初阶

一.命名空间

1.命名空间定义

2.命名空间使用

二.C++输入&输出

三.缺省参数

四. 函数重载

五.引用

1.常引用

2.传值、传引用效率比较

3.引用和指针的区别

4.引用和指针的不同点:

小知识点:

六.内联函数

七.auto关键字(C++11)

1.auto的使用细则

八.基于范围的for循环(C++11)

1.范围for的使用条件

九.空值nullptr

十.类与对象

1.class与struct

2.类的定义

类的两种定义方式：

1. 声明和定义全部放在类体中

2. 类声明放在.h文件中,成员函数定义放在.cpp文件中

①模版的情况下

3.成员变量命名规则的建议：

3.类的访问限定符及封装

1 访问限定符

2.访问限定符说明

访问限定符在继承中

3.C++中struct和class的区别是什么

4.封装

4.类的作用域

5.类的实例化

6.类对象模型

1 如何计算类对象的大小（结构体内存对齐）

7.this指针

8.类的6个默认成员函数

1.构造函数

内置类型和自定义类型在构造中

小知识点:

2.析构函数

内置类型和自定义类型在析构中

小知识点：析构顺序

析构顺序和次数

3.拷贝构造函数

内置类型和自定义类型在拷贝构造

9.赋值运算符重载

全局的operator==

类内的operator==

内置类型和自定义类型在赋值运算符重载

小知识点:

日期类的实现(已经弄完了)

10.初始化列表

成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关 小知识点:

11.static成员，explicit关键字

小知识点:

12this指针

this指针的特性

this在哪里

13.友元函数和友元类(Date里有)

友元类

十一.内存管理

C语言中动态内存管理方式：malloc/calloc/realloc/free

C++内存管理方式

new和delete操作自定义类型

operator new与operator delete函数

new和delete的实现原理

内置类型

自定义类型

定位new表达式(placement-new) （了解）

malloc/free和new/delete的区别

内存泄漏

小知识点new和delete【】匿名对象和重复释放

十二.函数模版和类模版

函数模板

函数模板概念

函数模板格式

函数模板的实例化

成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关

小知识点: