c++知识扫盲

怼烎@ 2023-07-13 05:55 2阅读 0赞

### 文章目录 ###

*  \->
 *  this指针
 *   *  this指针指向当前的对象
 *  使用if和else必须用\{\}以防调窜
 *  哑元：传入的参数不想用时可以只指定类型，写形参名不用会警告，改变传入的格式又很麻烦
 *  虚函数：基类中的虚函数允许派生类重写功能，编译器会保证派生类对象使用的是自己重写的功能
 *   *   *  “猫吃老鼠”
     *  再总结下“什么是虚函数”
     *  为什么类成员函数默认都不是虚函数？
 *  QDebug 输出调试信息
 *  宏
 *  QT的信号和槽
 *  Q\_OBJECT
 *   *   *  1.1 信号与槽
         *  1.2 信号
         *  1.3 槽
         *  1.4 信号与槽的关联
         *  2.一个小例子
         *  3.关于元对象工具MOC
 *  数据结构set
 *   *   *  一、set 的概念
         *  二、set 的基本操作
         *  三、set 的用法
 *  \++的前后顺序区别
 *  关于单引号双引号char和string
 *   *   *  关于字符串的拼接：
         *  string的某一位是字符，你可以用单引号的空格字符
         *  1、首先必须了解，string可以被看成是以字符为元素的一种容器。
         *  char也就是字符型数据定义，string也就是字符串类型数据定义，
 *  c++中的链表list
 *  关于堆栈

# \-> #

\->是指针的指向运算符，通常与结构体一起使用。

#include<stdio.h>
    struct stu   // 定义一个结构体
    {
        
        char name[10];  // 姓名
        int num;  // 学号
        int age;  // 年龄
    };
    void main()
    {
        
        struct stu *s;   // 定义一个结构体指针
        char str[]="ZhangLi";
        s->name = str;     // 对结构体中的成员变量name进行赋值
        s->num = 2015120;  // 对结构体中的成员变量num进行赋值
        s->age = 18;       // 对结构体中的成员变量age进行赋值
    }

# this指针 #

先要理解class的意思。class应该理解为一种类型，象int,char一样，是用户自定义的类型。用这个类型可以来声明一个变量，比如int x, myclass my等等。这样就像变量x具有int类型一样，变量my具有myclass类型。理解了这个，就好解释this了，my里的this 就是指向my的指针。如果还有一个变量myclass mz，mz的this就是指向mz的指针。 这样就很容易理解this 的类型应该是myclass *,而对其的解引用*this就应该是一个myclass类型的变量。

通常在class定义时要用到类型变量自身时，因为这时候还不知道变量名（为了通用也不可能固定实际的变量名），就用this这样的指针来使用变量自身。

1.  this指针的用处:  
    一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。  
    this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。例如，调用date.SetMonth(9) <===> SetMonth(&date, 9)，this帮助完成了这一转换 .  
    在成员函数内部，我们可以直接使用调用该函数的对象的成员，而无需通过成员访问运算符来做到这一点，因为this所指的正是这个对象。任何对类成员的直接访问都被看成this的隐式使用。  
    this的目的总是指向这个对象，所以this是一个常量指针，我们不允许改变this中保存的地址。
2.  this指针的使用:  
    一种情况就是，在类的非静态成员函数中返回类对象本身的时候，直接使用 return \*this；另外一种情况是当参数与成员变量名相同时，如this->n = n （不能写成n = n）。
3.  this指针程序示例:  
    this指针是存在与类的成员函数中,指向被调用函数所在的类实例的地址。  
    根据以下程序来说明this指针

#include<iostream.h>
    class Point
    {
         
      int x, y;
    public:
      Point(int a, int b) {
         x=a; y=b;}
      Void MovePoint( int a, int b){
         x+=a; y+=b;}
      Void print(){
         cout<<"x="<<x<<"y="<<y<<endl;}
    };
    void main( )
    {
        
       Point point1( 10,10); //定义一个类对象
       point1.MovePoint(2,2);
       point1.print( );
    }

当对象point1调用MovePoint(2,2)函数时，即将point1对象的地址传递给了this指针。  
MovePoint函数的原型应该是 void MovePoint( Point \*this, int a, int b);第一个参数是指向该类对象的一个指针，我们在定义成员函数时没看见是因为这个参数在类中是隐含的。这样point1的地址传递给了this，所以在MovePoint函数中便显式的写成：  
void MovePoint(int a, int b) \{ this->x +=a; this-> y+= b;\}  
即可以知道，point1调用该函数后，也就是point1的数据成员被调用并更新了值。  
即该函数过程可写成 point1.x+= a; point1. y + = b;

## this指针指向当前的对象 ##

![在这里插入图片描述][20200310230118331.png]  
对象a的内存地址和this指针的一模一样(都是0017F7E8)；而当运行到对象b的时候，它的内存地址又和它所对应的this指针指向的内存地址一模一样了(都是0017F7DC)。这就说明了this指针变量记录的是当前对象的内存地址，即this指针指向当前的对象！

# 使用if和else必须用\{\}以防调窜 #

# 哑元：传入的参数不想用时可以只指定类型，写形参名不用会警告，改变传入的格式又很麻烦 #

1、哑元  
a.) 只有类型没有参数名的参数，就叫哑元

如：int Fun(int a,int b,double);  //如第三个参数的这种情况就叫哑元
    
     b.) 哑元作用 
    
          1).向下兼容 如：函数 int Fun(int a,int b,double c);//2010年写的函数，在2011年的时候由于功能升级，不在需要第三个参，只需要将这个函数的第三参数必成如上函数即可。哑元。
    
          2).实现重载（也可以只是为函数重载而用） 重载运算符（前项++,后项++在单目运算符重载的时候，以示区别。）

2、使用，例子代码：

namespace FunDummy
    {
        
    	int Add(int a,int b,int)
    	{
        
    		return a+b;
    	}
     
     
    	int Add(int a,int c)
    	{
        
    		return a+c;
    	}

# 虚函数：基类中的虚函数允许派生类重写功能，编译器会保证派生类对象使用的是自己重写的功能 #

虚函数定义在基类中，其他继承此基类的派生类都可以重写该虚函数，因此虚函数是C++语言多态特性中非常重要的概念。但是派生类也可以重写基类中的其他的常规函数（非虚函数）呀，那为什么还要引入虚函数这样看起来很复杂的概念呢？

为什么要引入虚函数？

### “猫吃老鼠” ###

转自https://baijiahao.baidu.com/s?id=1653132502323288772&wfr=spider&for=pc

![定义了Animal（动物）和Cat（猫）两个][Animal_Cat]  
上面这段C++语言代码定义了Animal（动物）和Cat（猫）两个类，其中Cat继承了Animal（猫显然是动物），我们可以在 main() 函数中使用这两个类：

Animal *animal = new Animal;
    
    Cat *cat = new Cat;animal->eat();
    
    // 输出： "I'm eating generic food."
    
    cat->eat();
    
    // 输出： "I'm eating a rat."

到这里一切都挺好的，动物吃食物，猫吃老鼠，即使不使用virtual关键字定义虚函数也完全没有问题。

现在稍稍修改下这段C++语言代码，**引入另外一个函数func()**（暂时不考虑实用性，仅做示例），它的代码如下，请看：

void func(Animal *xyz){
        
    
    xyz->eat();
    
    }

在 main() 函数中调用 func() 函数，相关的C++语言代码示例如下，请看：

Animal *animal = new Animal;
    
    Cat *cat = new Cat;func(animal);
    
    // 输出： "I'm eating generic food."
    
    func(cat);
    
    // 输出： "I'm eating generic food."

出问题了~请注意第二个 func() 函数调用，我们传递了一个Cat对象指针给它，但是输出的却不是“I’m eating a rat.”！仔细观察一下，\**发现 func() 函数的参数类型是Animal xyz*，那么为了让 func() 函数也能输出“I’m eating a rat.”，只能重载 func() 函数了：

void func(Animal *xyz){
        
    
    xyz->eat();
    
    }
    
    void func(Cat *xyz){
        
    
    xyz->eat();
    
    }

现在 func() 函数能够根据输入参数类型的不同，输出不同的内容了。可是问题来了，Animal（动物）是一个基类，它能派生出的动物远远不止Cat（猫）一种，**若是派生出许多派生类，每个派生类都重载一遍 func() 函数，是不是太麻烦了？**

太麻烦了  
神奇的虚函数

在C++语言中，重写基类中的常规（非虚）函数当然是可以的，但是从上面的例子可以看出，**重写常规函数实现多态有时会带来非常麻烦的问题**，要避免这样的问题可以使用 virtual function（虚函数）。现在，**我们在 Animal 基类的 eat() 成员函数前加上virtual关键字**：

加上virtual关键字  
此时无需重载 func() 函数，仅保留一份func() 函数：

void func(Animal *xyz){
        
    
    xyz->eat();
    
    }

再执行下面的C++语言代码，输出就不同了：

func(animal);
    
    // 输出： "I'm eating generic food."
    
    func(cat);
    
    // 输出： "I'm eating a rat."

看来，C++语言中的虚函数的确有些过人之处，有必要好好了解一下它。

事实上，每一个C++程序员都不可能避开虚函数的，就像每一个C语言程序员都不可能避开指针一样。

## 再总结下“什么是虚函数” ##

\*\*基类中的虚函数允许派生类重写功能，编译器会保证派生类对象使用的是自己重写的功能，即使对象是通过基类指针访问的，例如前文中的 func(Animal \*xyz) 函数，func(cat) 输出的实际上是 Cat 类重写的功能。\*\*这是一个非常有用的特性，调用者甚至都不需要知道 Cat 等派生类的实现，因为只需使用基类 Animal 指针就能够轻易的调用所有派生类的重写功能。

基类的虚函数可以完全被重写，也可以部分的被重写，所谓的“部分被重写”，其实就是派生类在重写基类虚函数时，也可以调用基类虚函数的功能。

虚函数和常规函数被调用时有什么不同？

**常规的非虚函数是静态解析的，即在编译时即可根据指针指向的对象确定是否被调用**，例如文章开头的例子，如果 eat() 函数是非虚函数：

// eat() 函数不是虚函数
    
    Animal *animal = new Animal;
    
    Cat *cat = new Cat;
    
    animal->eat();
    
    // 输出： "I'm eating generic food."
    
    cat->eat();
    
    // 输出： "I'm eating a rat."

此时编译器在编译时就能确定 animal->eat() 调用的是 Animal::eat() 函数，cat->eat() 调用的是 Cat::eat() 函数。在 func(Animal \*xyz) 函数中，因为其形参是 Animal \*指针类型，所以即使传入的是 cat 对象指针，在 func() 函数内部也会被强制转换为Animal \*指针，因此 func(cat) 调用的仍然是 Animal::eat() 函数。

而虚函数就不同了，**它是动态解析的，也即在程序被编译后，运行时才根据对象的类型，而不是指向对象的指针类型决定其是否被调用，这就是说为的“动态绑定”。**

关于“动态绑定”，我们在下一节中再做详细讨论，这里先留个印象。

在C++语言中，如果某个类有虚函数，那么大多数编译器都会自动的为其对象维护一个隐藏的“**虚指针（virtul-pointer）**”，**虚指针指向一个全局“虚表（virtual-table）**”，虚表中存放若干函数指针，这些函数指针指向类中的虚函数。请看下面这段C++语言代码：

class A {
        
    
    public:
    
    virtual void vfoo1();
    
    virtual void vfoo2();
    
    void foo1();
    
    void foo2();
    
    private:
    
    int prv_i1, prv_i2;
    
    };

显然，类 A 有两个常规函数以及两个 int 型的成员变量，此外，它还有两个虚函数，因此编译器会创建一个虚表，\*\*虚表中存放的是函数指针，它们分别指向类 A 的虚函数，\*\*如下图所示：

类A的虚表和虚函数  
这里应注意，虚表是属于类的，而不是对象的，也就是说，即使有成千上万个 A 对象，虚表也仅有一个，这些对象共用一个类虚表。编译器会自动的为每个对象创建一个隐藏的“虚指针”\_\_vptr，它指向类 A 的虚表，如下图所示：

隐藏的“虚指针”\_\_vptr  
C++语言这样实现虚函数机制的空间开销是微乎其微的，事实上，每一个对象只需要一个额外的“虚指针”\_\_vptr就能够调用类的虚函数。同样的，时间开销也很小：相比于常规函数的调用，虚函数的调用只不过多出了额外的两个步骤：

获取虚表指针，得到虚表从虚表中取出虚函数的地址读者应注意，这里的讨论为了突出主题，理想化了一些情况。

## 为什么类成员函数默认都不是虚函数？ ##

既然虚函数这么好用，那为什么C++语言不把类的成员函数默认定义为虚函数呢？

其实仔细考虑一下，**虚函数的“好用”主要体现在定义在基类中实现多态上**，但并不是所有的类都需要被设计为基类，一昧的使用虚函数可能会造成语义上的歧义，隐藏程序员的设计。仅将需要被继承的基类中需要被重写的函数定义为虚函数，要比将所有函数定义为虚函数清晰多了。

此外，经过前面的讨论，我们也知道**虚函数的效率实际上是没有常规函数高的**，同样的功能中，仅从被调用过程来看，它的时间开销和空间开销都比常规函数高，每个对象还需要额外的**虚指针索引虚表**。

# QDebug 输出调试信息 #

原文链接：https://blog.csdn.net/Amnes1a/article/details/64438778

在程序开发过程中，我们经常需要打印一些调试信息到终端，以供我们开发人员快速定位软件的问题所在。而QDebug类就是用来完成这样的功能的一个类。使用QDebug类，我们可以将调试信息打印到控制台、文件、甚至某个字符串中。其构造函数如下：

QDebug(QIODevice *device)
    QDebug(QString *string)
    QDebug(QtMsgType type)
    QDebug(const QDebug &other)

不过，通常情况下，我们并不直接创建这个类的对象来输出调试信息。因为，Qt中，为我们提供了相应的便捷函数，如qDebug()，改函数会为我们自动创建一个默认的QDebug对象。如下代码所示：

qDebug() << "Date:" << QDate::currentDate();
      qDebug() << "Types:" << QString("String") << QChar('x') << QRect(0, 10, 50, 40);
      qDebug() << "Custom coordinate type:" << coordinate;

其中，qDebug() 使用接收QtMsgType类型值得构造函数还创建一个QDebug() 对象。类似的，Qt还为我们提供了qWarning()、qCritical()、qFatal()、qInfo() 函数，根据不同的消息类型创建出不同的QDebug对象。QtMsgType的详细声明如下：

> Constant	Value	Description QtDebugMsg	0	A  message generated by the
    > qDebug() function QtWarningMsg	1	A  message generated by the
    > qWarning() function QtCriticalMsg	2	A  message generated by the
    > qCritial() function QtFatalMsg	3	A  message generated by the qFatal()
    > function QtInfoMsg	4	A  message generated by the qInfo() function
    > QtSystemMsg	QtCrtitialMsg

QDebug会自动格式化其输出，以使输出更可读。它会自动地在参数中间添加空格，并在输出QString、QByteArray、QChar参数时，自动为这些内容添加双引号。当然，我们也可改变这些默认选项，通过使用相关的成员函数，比如space()、nospace()、quote()、noquote()。而且，文本流中常用的格式符也可以在QDebug中使用。

QDebug中已经针对很多数据类型为我们重载了<< 运算符，能满足我们一般的调试需求。若实在想添加对自己的某种自定义类型的支持，也可以自己再重载<< 即可。如下面的例子所示：

struct Student
    {
        
          QString name;
          QString sex;
    };  
    QDebug operator<<(QDebug debug, const Student &s)
    {
        
          QDebugStateSaver saver(debug);
          debug.nospace() << '[' << s.name << ", " << s.sex << ']';
     
          return debug;
    }

其中，用到了QDebugStateSaver类。该类其实就是在自定义QDebug运算符时，先保存QDebug当当前设置，然后我们可以根据自动的需要修改相关设置，进而输入我们需要的格式信息；当saver对象，超出作用域进行析构时，会自动恢复QDebug的状态。

至于QDebug的成员函数，我目前主要是使用noquote() 函数。上面我们说过，QDebug在输出QString 和 QByteArray等类型的内容时，会自动为它们添加双引号。而有时，在反而会让控制台的信息更密集，不便于快速分析结果。所以，我经常使用该函数，修改此默认设置。如下代码所示：

#include <QCoreApplication>
    #include <QDebug>
     
    int main(int argc, char *argv[])
    {
        
        QCoreApplication a(argc, argv);
     
        QString s = "hello";
        qDebug() << s;
        qDebug().noquote() << s;
        return a.exec();
    }

# 宏 #

宏在编译时就被替换成它内部的语句了，而函数是运行时调用的  
所以如果是简单的东西就写成宏，这样没有调用函数的开销，效率会高一些。相反，由于宏每被调用一次，就相当于把代码复制一份，所以如果比较复杂的宏被多次调用的话，会增加代码的体积。因此，太复杂的运算就写成函数比较好了。  
另外，要注意在宏调用时使用自增自减运算符可能会有意想不到的结果。

# QT的信号和槽 #

信号槽是 Qt 框架引以为豪的机制之一。所谓信号槽，实际就是观察者模式。当某个事件发生之后，比如，按钮检测到自己被点击了一下，它就会发出一个信号（signal）。这种发出是没有目的的，类似广播。如果有对象对这个信号感兴趣，它就会使用连接（connect）函数，意思是，将想要处理的信号和自己的一个函数（称为槽（slot））绑定来处理这个信号。也就是说，当信号发出时，被连接的槽函数会自动被回调。这就类似观察者模式：当发生了感兴趣的事件，某一个操作就会被自动触发。（这里提一句，Qt 的信号槽使用了额外的处理来实现，并不是 GoF 经典的观察者模式的实现方式。）

信号和槽是Qt特有的信息传输机制，是Qt设计程序的重要基础，它可以让互不干扰的对象建立一种联系。

槽的本质是类的成员函数，其参数可以是任意类型的。和普通C++成员函数几乎没有区别，它可以是虚函数；也可以被重载；可以是公有的、保护的、私有的、也可以被其他C++成员函数调用。唯一区别的是：槽可以与信号连接在一起，每当和槽连接的信号被发射的时候，就会调用这个槽。

链接：https://www.jianshu.com/p/d6fc0bb0689a  
来源：简书

# Q\_OBJECT #

只有加入了Q\_OBJECT，才能使用QT中的signal和slot机制，而且Q\_OBJECT要放在类的最前面  
1.QT的信号与槽机制介绍

### 1.1 信号与槽 ###

**信号和槽机制是 QT 的核心机制**，要精通 QT 编程就必须对信号和槽有所了解。信号和槽是一种高级接口，应用于对象之间的通信，它是 QT 的核心特性，也是 QT 区别于其它工具包的重要地方。信号和槽是 QT 自行定义的一种通信机制，它独立于标准的 C/C++ 语言，因此要正确的处理信号和槽，必须借助一个称为 **moc（Meta Object Compiler）的 QT 工具，该工具是一个 C++ 预处理程序，它为高层次的事件处理自动生成所需要的附加代码。**  
在我们所熟知的很多 GUI 工具包中，**窗口小部件 (widget) 都有一个回调函数用于响应它们能触发的每个动作，这个回调函数通常是一个指向某个函数的指针**。但是，在 QT 中信号和槽取代了这些凌乱的函数指针，使得我们编写这些通信程序更为简洁明了。 信号和槽能携带任意数量和任意类型的参数，他们是类型完全安全的，不会像回调函数那样产生 core dumps。  
**所有从 QObject 或其子类 ( 例如 Qwidget) 派生的类都能够包含信号和槽**。当对象改变其状态时，信号就由该对象发射 (emit) 出去，这就是对象所要做的全部事情，它不知道另一端是谁在接收这个信号。这就是真正的信息封装，它确保对象被当作一个真正的软件组件来使用。槽用于接收信号，但它们是普通的对象成员函数。一个槽并不知道是否有任何信号与自己相连接。而且，对象并不了解具体的通信机制。  
可以将很多信号与单个的槽进行连接，也可以将单个的信号与很多的槽进行连接，甚至于将一个信号与另外一个信号相连接也是可能的，这时无论第一个信号什么时候发射系统都将立刻发射第二个信号。总之，信号与槽构造了一个强大的部件编程机制。

### 1.2 信号 ###

当某个信号对其客户或所有者发生的内部状态发生改变，信号被一个对象发射。只有定义过这个信号的类及其派生类能够发射这个信号。当一个信号被发射时，与其相关联的槽将被立刻执行，就象一个正常的函数调用一样。信号 - 槽机制完全独立于任何 GUI 事件循环。只有当所有的槽返回以后发射函数（emit）才返回。 如果存在多个槽与某个信号相关联，那么，当这个信号被发射时，这些槽将会一个接一个地执行，但是它们执行的顺序将会是随机的、不确定的，我们不能人为地指定哪个先执行、哪 个后执行。  
信号的声明是在头文件中进行的，QT 的 signals 关键字指出进入了信号声明区，随后即可声明自己的信号。例如，下面定义了三个信号：

signals: 
      voiySignd mal(); 
      void mySignal(int x); 
      void mySignalParam(int x,int y);

在上面的定义中，signals 是 QT 的关键字，而非 C/C++ 的。接下来的一行 void mySignal() 定义了信号 mySignal，这个信号没有携带参数；接下来的一行 void mySignal(int x) 定义 了重名信号 mySignal，但是它携带一个整形参数，这有点类似于 C++ 中的虚函数。从形式上 讲信号的声明与普通的 C++ 函数是一样的，但是信号却没有函数体定义，另外，信号的返回类型都是 void，不要指望能从信号返回什么有用信息。  
信号由moc自动产生，它们不应该在 .cpp 文件中实现。

### 1.3 槽 ###

槽是普通的 C++ 成员函数，可以被正常调用，它们唯一的特殊性就是很多信号可以与其相关联。当与其关联的信号被发射时，这个槽就会被调用。槽可以有参数，但槽的参数不能有缺省值。  
既然槽是普通的成员函数，因此与其它的函数一样，它们也有存取权限。槽的存取权限决定了谁能够与其相关联。同普通的 C++ 成员函数一样，槽函数也分为三种类型，即 public slots、private slots 和 protected slots。

public slots：在这个区内声明的槽意味着任何对象都可将信号与之相连接。这对于组件编程非常有用，可以创建彼此互不了解的对象，将它们的信号与槽进行连接以便信息能够正确的传递。  
protected slots：在这个区内声明的槽意味着当前类及其子类可以将信号与之相连接。适用于那些槽，它们是类实现的一部分，但是其界面接口却面向外部。  
private slots：在这个区内声明的槽意味着只有类自己可以将信号与之相连接。适用于联系非常紧密的类。  
槽也能够声明为虚函数，这也是非常有用的。  
槽的声明也是在头文件中进行的。例如，下面声明了三个槽：

public slots: 
      void mySlot(); 
      void mySlot(int x); 
      void mySignalParam(int x,int y);

### 1.4 信号与槽的关联 ###

通过调用 QObject 对象的 connect 函数来将某个对象的信号与另外一个对象的槽函数相关联，这样当发射者发射信号时，接收者的槽函数将被调用。该函数的定义如下：

bool QObject::connect ( const QObject * sender, const char * signal, 
    		 const QObject * receiver, const char * member ) [static]

这个函数的作用就是将发射者 sender 对象中的信号 signal 与接收者 receiver 中的 member 槽函数联系起来。当指定信号 signal 时必须使用 QT 的宏 SIGNAL()，当指定槽函数时必须使用宏 SLOT()。如果发射者与接收者属于同一个对象的话，那么在 connect 调用中接收者参数可以省略。  
例如，下面定义了两个对象：标签对象 label 和滚动条对象 scroll，并将 valueChanged() 信号与标签对象的 setNum() 相关联，另外信号还携带了一个整形参数，这样标签总是显示滚动条所处位置的值。

QLabel     *label  = new QLabel; 
    QScrollBar *scroll = new QScrollBar; 
    QObject::connect( scroll, SIGNAL(valueChanged(int)), label,  SLOT(setNum(int)) );

### 2.一个小例子 ###

//tsignal.h 
     class TsignalApp:public QMainWindow 
     {
         
    	 Q_OBJECT 
    	 ... 
    	 // 信号声明区
    	 signals: 
    		 // 声明信号 mySignal() 
    		 void mySignal(); 
    		 // 声明信号 mySignal(int) 
    		 void mySignal(int x); 
    		 // 声明信号 mySignalParam(int,int) 
    		 void mySignalParam(int x,int y); 
    	 // 槽声明区
    	 public slots: 
    		 // 声明槽函数 mySlot() 
    		 void mySlot(); 
    		 // 声明槽函数 mySlot(int) 
    		 void mySlot(int x); 
    		 // 声明槽函数 mySignalParam (int，int) 
    		 void mySignalParam(int x,int y); 
     } 
     ... 
     //tsignal.cpp 
     ... 
     TsignalApp::TsignalApp() 
     {
         
    	 ... 
    	 // 将信号 mySignal() 与槽 mySlot() 相关联
    	 connect(this,SIGNAL(mySignal()),SLOT(mySlot())); 
    	 // 将信号 mySignal(int) 与槽 mySlot(int) 相关联
    	 connect(this,SIGNAL(mySignal(int)),SLOT(mySlot(int))); 
    	 // 将信号 mySignalParam(int,int) 与槽 mySlotParam(int,int) 相关联
    	 connect(this,SIGNAL(mySignalParam(int,int)),SLOT(mySlotParam(int,int))); 
     } 
     // 定义槽函数 mySlot() 
     void TsignalApp::mySlot() 
     {
         
    	 QMessageBox::about(this,"Tsignal", "This is a signal/slot sample without 
     parameter."); 
     } 
     // 定义槽函数 mySlot(int) 
     void TsignalApp::mySlot(int x) 
     {
         
    	 QMessageBox::about(this,"Tsignal", "This is a signal/slot sample with one 
     parameter."); 
     } 
     // 定义槽函数 mySlotParam(int,int) 
     void TsignalApp::mySlotParam(int x,int y) 
     {
         
    	 char s[256]; 
    	 sprintf(s,"x:%d y:%d",x,y); 
    	 QMessageBox::about(this,"Tsignal", s); 
     } 
     void TsignalApp::slotFileNew() 
     {
         
    	 // 发射信号 mySignal() 
    	 emit mySignal(); 
    	 // 发射信号 mySignal(int) 
    	 emit mySignal(5); 
    	 // 发射信号 mySignalParam(5，100) 
    	 emit mySignalParam(5,100); 
     }

### 3.关于元对象工具MOC ###

**元对象编译器 moc（meta object compiler）对 C++ 文件中的类声明进行分析并产生用于初始化元对象的 C++ 代码，元对象包含全部信号和槽的名字以及指向这些函数的指针。**  
moc 读 C++ 源文件，如果发现有 **Q\_OBJECT 宏声明的类，它就会生成另外一个 C++ 源文件**，这个新生成的文件中包含有该类的元对象代码。例如，假设我们有一个头文件 mysignal.h，在这个文件中包含有信号或槽的声明，那么在编译之前 moc 工具就会根据该文件自动生成一个名为 mysignal.moc.h 的 C++ 源文件并将其提交给编译器；类似地，对应于 mysignal.cpp 文件 moc 工具将自动生成一个名为 mysignal.moc.cpp 文件提交给编译器。  
**元对象代码是 signal/slot 机制所必须的**。用 moc 产生的 C++ 源文件必须与类实现一起进行编译和连接，或者用 \#include 语句将其包含到类的源文件中。moc 并不扩展 \#include 或者 \#define 宏定义 , 它只是简单的跳过所遇到的任何预处理指令。

原文链接：https://blog.csdn.net/shenziheng1/article/details/78055056

# 数据结构set #

### 一、set 的概念 ###

set 的含义是集合，它是一个有序的容器，里面的元素都是排序好的，支持插入，删除，查找等操作，就像一个集合一样。所有的操作的都是严格在logn时间之内完成，效率非常高。set 和 multiset 的区别是：**set 插入的元素不能相同，但是 multiset 可以相同**。其特点如下：

每个元素的键值都唯一，不允许两个元素有相同的键值。  
所有元素都会根据元素的键值自动排序（默认从小到大）。  
set 中的元素不像 map 那样可以同时拥有实值(value)和键值(key)，只能存储键，是单纯的键的集合。  
set 中元素的值不能直接被改变。  
set 支持大部分的map的操作，但是 set 不支持下标的操作，而且没有定义mapped\_type类型。

### 二、set 的基本操作 ###

使用STL标准库的 set 时，应包含头文件：\#include

1、set 的定义及初始化

set<Type> s						      //定义一个set容器
    set<Type> s(s1)			              //定义一个set容器，并用容器s1来初始化
    set<Type> s(b, e)					  //b和e分别为迭代器的开始和结束的标记
    set<Type> s(s1.begin(), s1.begin()+3) //用容器s1的第0个到第2个值初始化s
    set<Type> s(a, a + 5)      		      //将a数组的元素初始化vec向量，不包括a[4]
    set<Type> s(&a[1], &a[4]) 			  //将a[1]~a[4]范围内的元素作为s的初始值

2、set 的基本操作

s.begin()					//返回指向第一个元素的迭代器
    s.end()						//返回指向最后一个元素的迭代器
    s.clear()					//清除所有元素
    s.count()					//返回某个值元素的个数
    s.empty()					//如果集合为空，返回true，否则返回false
    s.equal_range()				//返回集合中与给定值相等的上下限的两个迭代器
    s.erase()					//删除集合中的元素
    s.find(k)					//返回一个指向被查找到元素的迭代器
    s.insert()					//在集合中插入元素
    s.lower_bound(k)			//返回一个迭代器，指向键值大于等于k的第一个元素
    s.upper_bound(k)			//返回一个迭代器，指向键值大于k的第一个元素
    s.max_size()				//返回集合能容纳的元素的最大限值
    s.rbegin()					//返回指向集合中最后一个元素的反向迭代器
    s.rend()					//返回指向集合中第一个元素的反向迭代器
    s.size()					//集合中元素的数目

没有push-back

### 三、set 的用法 ###

1、基本用法：

#include <iostream>
    #include <set>
    using namespace std;
    int main(){
        
         set<int> s;
         s.insert(1);
         s.insert(2);
         s.insert(3);
         s.insert(1);
         cout<<"set的size值为 ："<<s.size()<<endl;
         cout<<"set的maxsize的值为 ："<<s.max_size()<<endl;
         cout<<"set中的第一个元素是 ："<<*s.begin()<<endl;
         cout<<"set中的最后一个元素是:"<<*s.end()<<endl;
         s.clear();
         if(s.empty())
             cout<<"set为空"<<endl;
         cout<<"set的size值为 ："<<s.size()<<endl;
         cout<<"set的maxsize的值为 ："<<s.max_size()<<endl;
         return 0;
    }

插入3之后虽然插入了一个1，但set中最后一个值仍然是3 。一共插入了4个数，但是集合中只有3个数并且是有序的，说明了set集合的两个特点，有序和不重复。  
begin() 和 end()函数是不检查set是否为空的，使用前最好使用empty()检验一下set是否为空。

2、count() 的用法

//返回某个值元素的个数
    #include <iostream>
    #include <set>
    using namespace std;
    int main(){
        
         set<int> s;
         s.insert(1);
         s.insert(2);
         s.insert(3);
         s.insert(1);
         cout<<"set 中 1 出现的次数是 ："<<s.count(1)<<endl;
         cout<<"set 中 4 出现的次数是 ："<<s.count(4)<<endl;
         return 0;
    }

总结： count() 用来查找set中某个键值出现的次数，但因为一个键值在set只可能出现0或1次，这样就变成了判断某一键值是否在set出现过了，所以这个函数在set中并不是很实用。

3、erase() 的用法

erase(iterator) ：删除定位器iterator指向的值

erase(first,second)：删除定位器first和second之间的值

erase(key\_value)：删除键值key\_value的值

#include <iostream>
    #include <set>
    using namespace std;
    int main(){
        
         set<int> s;
         set<int>::const_iterator it;
         set<int>::iterator first;
         set<int>::iterator second;
         for(int i=1; i<=10; ++i)
             s.insert(i);
         //第一种删除，删掉1
         s.erase(s.begin());
         //第二种删除，删掉2和3
         first = s.begin();
         second = s.begin();
         second++;
         second++;
         s.erase(first,second);
         //第三种删除，删掉8
         s.erase(8);
         cout<<"删除后 set 中元素是 ：";
         for(it=s.begin(); it!=s.end(); ++it)
             cout<<*it<<" ";
         cout<<endl;
         return 0;
    }

总结： set中的删除操作是不进行任何的错误检查的，比如定位器的是否合法等等，所以用的时候自己一定要注意。

4、find() 的用法

//返回一个指向被查找到元素的迭代器，如果没找到则返回end()
    #include <iostream>
    #include <set>
    using namespace std;
    int main(){
        
         int a[] = {
        4,5,6};
         set<int> s(a,a+3);
         set<int>::iterator it;
         if((it=s.find(4))!=s.end())
             cout<<*it<<endl;
         return 0;
    }

5、insert() 的用法

insert(key\_value)：将key\_value插入到set中 ，返回值是pairset::iterator,bool，bool标志着插入是否成功，而iterator代表插入的位置；若key\_value已经在set中，则iterator表示的key\_value在set中的位置。

inset(first,second);将定位器first到second之间的元素插入到set中，返回值是void.

#include <iostream>
    #include <set>
    using namespace std;
    int main(){
        
         int a[] = {
        1,2,3};
         set<int> s;
         set<int>::iterator it;
         s.insert(a,a+3);
         for(it=s.begin(); it!=s.end(); ++it)
             cout<<*it<<" ";
         cout<<endl;
         pair<set<int>::iterator,bool> pr;
         pr=s.insert(5);
         if(pr.second)
             cout<<*pr.first<<endl;
         cout<<"插入数值之后的set中有："<<endl;
    	 for(it=s.begin(); it!=s.end(); ++it)
    		cout<<*it<<" ";
    	 cout<<endl;
         return 0;
    }

6、lower\_bound()、upper\_bound() 的用法

lower\_bound(key\_value) ：返回第一个大于等于key\_value的定位器

upper\_bound(key\_value)：返回第一个大于key\_value的定位器

#include <iostream>
    #include <set>
    using namespace std;
    int main(){
        
         set<int> s;
         s.insert(1);
         s.insert(3);
         s.insert(4);
         s.insert(6);
         cout<<*s.lower_bound(1)<<endl;
         cout<<*s.lower_bound(2)<<endl;
         cout<<*s.upper_bound(3)<<endl;
         return 0;
    }

7、equal\_range() 的用法

equal\_range()：返回一对定位器，分别表示第一个大于等于给定关键值的元素和第一个大于给定关键值的元素，这个返回值是一个pair类型。如果这一对定位器中哪个返回失败，就会等于end()的值。

#include <iostream>
    #include <set>
    #include <algorithm>
    using namespace std;
    int main(){
        
    	set<int> s;
    	set<int>::iterator it;
    	for(int i=1; i<=5; ++i)
    		s.insert(i); //向set中加入数据
    	for(it=s.begin(); it!=s.end(); ++it)
    		cout<<*it<<" ";  //输出set中的数据
    	cout<<endl;
    	pair<set<int>::const_iterator,set<int>::const_iterator> pr;
    	pr=s.equal_range(3);
    	cout<<"第一个大于等于3的数是："<<*pr.first<<endl;
    	cout<<"第一个大于3的数是： "<<*pr.second<<endl;
    	return 0;
    }

8、自定义比较函数

（1）元素不是结构体：

//自定义比较函数myComp,重载“（）”操作符
    struct myComp{
        
    	bool operator()(const your_type &a,const your_type &b){
        
    		return a.data > b.data;
    	}
    }
    set<int,myComp>s;
    set<int,myComp>::iterator it;

（2）元素是结构体：

//可以直接将比较函数写在结构体内
    struct Info{
        
    	string name;
    	float score;
    	//重载“<”操作符，自定义排序规则
    	bool operator < (const Info &a) const{
        
    		//按score从大到小排列
    		return a.score<score;
    	}
    }

# \++的前后顺序区别 #

**i++,是i先赋值后自增；  
\++i,是i先自增后赋值；**  
如果只是一条单独语句，没区别,因为没有赋值对象；只有自增；  
如果是存在赋值对象，比如n=++i和n=i++就不同；  
比如i=9;执行n=++i,i先自增，然后赋值，n=10;  
同样i=9;执行n=i++,i先赋值，然后自增，n=9;

# 关于单引号双引号char和string #

### 关于字符串的拼接： ###

1.  string+string 可

2.string+char 可

3.string +char数组 可  
4.char + char 不可

//字符串常量不能与字符常量互换
    //字符常量‘s’是ASCII码83的另一种写法
    char ch1 = 's';
    //字符串常量"s" 包括了‘s’还有‘0’
    char ch2 = "s";

### string的某一位是字符，你可以用单引号的空格字符 ###

string它是char类型的模板类

如果你看了string的源码，那你就很明白了；实际上string类是对char的封装，它的内部数据成员是一个char\*；因此肯定是使用单引号

### 1、首先必须了解，string可以被看成是以字符为元素的一种容器。 ###

字符构成序列（字符串）。有时候在字符序列中进行遍历，标准的string类提供了STL容器接口。具有一些成员函数比如begin()、end()，迭代器可以根据他们进行定位。

注意，与char*不同的是，string不一定以NULL(’\\0’)结束。string长度可以根据length()得到，string可以根据下标访问。所以，不能将string直接赋值给char*。

2、string 转换成 char \*

如果要将string直接转换成const char \*类型。string有2个函数可以运用。

一个是.c\_str()，一个是data成员函数。

例子如下：

string s1 = "abcdeg";
    const char *k = s1.c_str();
    const char *t = s1.data();
    printf("%s%s",k,t);
    cout<<k<<t<<endl;

如上，都可以输出。内容是一样的。但是只能转换成const char\*，如果去掉const编译不能通过。

那么，如果要转换成char\*，可以用string的一个成员函数copy实现。

string s1 = "abcdefg";
    char *data;
    int len = s1.length();
    data = (char *)malloc((len+1)*sizeof(char));
    s1.copy(data,len,0);
    printf("%s",data);
    cout<<data;

### char也就是字符型数据定义，string也就是字符串类型数据定义， ###

乍一看他们很想，一个是字符一个是字符串，字符串不就是字符串起来得到的吗？但是事实上，字符串即是“字符”串起来也不是“字符”串起来，听起来是不是很奇怪，这里面的两个字符的意义其实是不一样的，第一个“字符”的意思是指一个单位的字形、类字形单位或符号的基本信息，而第二个“字符”的意思是字符类型。可能大家听得还是很糊涂，我帮大家捋一捋，我们现在要先弄清楚一点，char是字符类型，属于一个类，属于编程语言中的一个数据类型，而他和字符有区别，字符是什么？字符指的是一个基本信息单位，也就是说字符是一个数据，它可以是数字也可以是字母。

所以，char是一个可以用来存储字符数据的变量类型，而string就是一个存储一串字符数据的变量类型，他们的共同点就是他们都是变量类型，都是用来存储字符的。

我想这样说大家应该明白了，既然他们俩如此相像，也就免不了他们要常常互动了，不过在讲他们的交互之前，我要和大家再提一个概念，不过希望大家能先理清刚刚讲的再看，不然会越看越乱的。

下面我要说的就是字符数组，char\[\]，他是一组char类变量组成的，也可以用来存储一串字符数据，和string的作用很是相像，但是本质是不一样的，他们应该是数组变量，一个是类变量，char\[\]很好理解，他就是一个数组，每个单元里面放一个字符数据，string则是一个整体，最后以字符’\\0’，作为分隔标识，而且他还有很多类函数可以调用使用。

原文链接：https://blog.csdn.net/Yu1543376365/article/details/79176606

# c++中的链表list #

先说明一点，c++中的arr数组改变不方便，没有相应的方法，所以不过多使用；

Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除，但是随机访问却比较慢.
    
    assign() 给list赋值 
    back() 返回最后一个元素 
    begin() 返回指向第一个元素的迭代器 
    clear() 删除所有元素 
    empty() 如果list是空的则返回true 
    end() 返回末尾的迭代器 
    erase() 删除一个元素 
    front() 返回第一个元素 
    get_allocator() 返回list的配置器 
    insert() 插入一个元素到list中 
    max_size() 返回list能容纳的最大元素数量 
    merge() 合并两个list 
    pop_back() 删除最后一个元素 
    pop_front() 删除第一个元素 
    push_back() 在list的末尾添加一个元素 
    push_front() 在list的头部添加一个元素 
    rbegin() 返回指向第一个元素的逆向迭代器 
    remove() 从list删除元素 
    remove_if() 按指定条件删除元素 
    rend() 指向list末尾的逆向迭代器 
    resize() 改变list的大小 
    reverse() 把list的元素倒转 
    size() 返回list中的元素个数 
    sort() 给list排序 
    splice() 合并两个list 
    swap() 交换两个list 
    unique() 删除list中重复的元素
    
    实例一：
    [cpp] view plain copy
    #include <iostream>   
    #include <list>   
    #include <numeric>   
    #include <algorithm>   
    using namespace std;   
    
    //创建一个list容器的实例LISTINT   
    typedef list<int> LISTINT;   
    //创建一个list容器的实例LISTCHAR   
    typedef list<int> LISTCHAR;   
    
    void main()   
    {
           
        //用list容器处理整型数据    
        //用LISTINT创建一个名为listOne的list对象   
        LISTINT listOne;   
        //声明i为迭代器   
        LISTINT::iterator i;   
    
        //从前面向listOne容器中添加数据   
        listOne.push_front (2);   
        listOne.push_front (1);   
    
        //从后面向listOne容器中添加数据   
        listOne.push_back (3);   
        listOne.push_back (4);   
    
        //从前向后显示listOne中的数据   
        cout<<"listOne.begin()--- listOne.end():"<<endl;   
        for (i = listOne.begin(); i != listOne.end(); ++i)   
            cout << *i << " ";   
        cout << endl;   
    
        //从后向后显示listOne中的数据   
        LISTINT::reverse_iterator ir;   
        cout<<"listOne.rbegin()---listOne.rend():"<<endl;   
        for (ir =listOne.rbegin(); ir!=listOne.rend();ir++) {
           
            cout << *ir << " ";   
        }   
        cout << endl;   
    
        //使用STL的accumulate(累加)算法   
        int result = accumulate(listOne.begin(), listOne.end(),0);   
        cout<<"Sum="<<result<<endl;   
        cout<<"------------------"<<endl;   
    
        //--------------------------   
        //用list容器处理字符型数据   
        //--------------------------   
    
        //用LISTCHAR创建一个名为listOne的list对象   
        LISTCHAR listTwo;   
        //声明i为迭代器   
        LISTCHAR::iterator j;   
    
        //从前面向listTwo容器中添加数据   
        listTwo.push_front ('A');   
        listTwo.push_front ('B');   
    
        //从后面向listTwo容器中添加数据   
        listTwo.push_back ('x');   
        listTwo.push_back ('y');   
    
        //从前向后显示listTwo中的数据   
        cout<<"listTwo.begin()---listTwo.end():"<<endl;   
        for (j = listTwo.begin(); j != listTwo.end(); ++j)   
            cout << char(*j) << " ";   
        cout << endl;   
    
        //使用STL的max_element算法求listTwo中的最大元素并显示   
        j=max_element(listTwo.begin(),listTwo.end());   
        cout << "The maximum element in listTwo is: "<<char(*j)<<endl;   
    }   
    
    结果：
    listOne.begin()--- listOne.end():
    1 2 3 4
    listOne.rbegin()---listOne.rend():
    4 3 2 1
    Sum=10
    ------------------
    listTwo.begin()---listTwo.end():
    B A x y
    The maximum element in listTwo is: y
    Press any key to continue
    
    实例二：
    [cpp] view plain copy
    #include <iostream>   
    #include <list>   
    
    using namespace std;   
    typedef list<int> INTLIST;   
    
    //从前向后显示list队列的全部元素   
    void put_list(INTLIST list, char *name)   
    {
           
        INTLIST::iterator plist;   
    
        cout << "The contents of " << name << " : ";   
        for(plist = list.begin(); plist != list.end(); plist++)   
            cout << *plist << " ";   
        cout<<endl;   
    }   
    
    //测试list容器的功能   
    void main(void)   
    {
           
        //list1对象初始为空   
        INTLIST list1;   
        //list2对象最初有10个值为6的元素   
        INTLIST list2(10,6);   
        //list3对象最初有3个值为6的元素   
        INTLIST list3(list2.begin(),--list2.end());   
    
        //声明一个名为i的双向迭代器   
        INTLIST::iterator i;   
    
        //从前向后显示各list对象的元素   
        put_list(list1,"list1");   
        put_list(list2,"list2");   
        put_list(list3,"list3");   
    
        //从list1序列后面添加两个元素   
        list1.push_back(2);   
        list1.push_back(4);   
        cout<<"list1.push_back(2) and list1.push_back(4):"<<endl;   
        put_list(list1,"list1");   
    
        //从list1序列前面添加两个元素   
        list1.push_front(5);   
        list1.push_front(7);   
        cout<<"list1.push_front(5) and list1.push_front(7):"<<endl;   
        put_list(list1,"list1");   
    
        //在list1序列中间插入数据   
        list1.insert(++list1.begin(),3,9);   
        cout<<"list1.insert(list1.begin()+1,3,9):"<<endl;   
        put_list(list1,"list1");   
    
        //测试引用类函数   
        cout<<"list1.front()="<<list1.front()<<endl;   
        cout<<"list1.back()="<<list1.back()<<endl;   
    
        //从list1序列的前后各移去一个元素   
        list1.pop_front();   
        list1.pop_back();   
        cout<<"list1.pop_front() and list1.pop_back():"<<endl;   
        put_list(list1,"list1");   
    
        //清除list1中的第2个元素   
        list1.erase(++list1.begin());   
        cout<<"list1.erase(++list1.begin()):"<<endl;   
        put_list(list1,"list1");   
    
        //对list2赋值并显示   
        list2.assign(8,1);   
        cout<<"list2.assign(8,1):"<<endl;   
        put_list(list2,"list2");   
    
        //显示序列的状态信息   
        cout<<"list1.max_size(): "<<list1.max_size()<<endl;   
        cout<<"list1.size(): "<<list1.size()<<endl;   
        cout<<"list1.empty(): "<<list1.empty()<<endl;   
    
        //list序列容器的运算   
        put_list(list1,"list1");   
        put_list(list3,"list3");   
        cout<<"list1>list3: "<<(list1>list3)<<endl;   
        cout<<"list1<list3: "<<(list1<list3)<<endl;   
    
        //对list1容器排序   
        list1.sort();   
        put_list(list1,"list1");   
    
        //结合处理   
        list1.splice(++list1.begin(), list3);   
        put_list(list1,"list1");   
        put_list(list3,"list3");   
    }   
    
    结果：
    The contents of list1 :
    The contents of list2 : 6 6 6 6 6 6 6 6 6 6
    The contents of list3 : 6 6 6 6 6 6 6 6 6
    list1.push_back(2) and list1.push_back(4):
    The contents of list1 : 2 4
    list1.push_front(5) and list1.push_front(7):
    The contents of list1 : 7 5 2 4
    list1.insert(list1.begin()+1,3,9):
    The contents of list1 : 7 9 9 9 5 2 4
    list1.front()=7
    list1.back()=4
    list1.pop_front() and list1.pop_back():
    The contents of list1 : 9 9 9 5 2
    list1.erase(++list1.begin()):
    The contents of list1 : 9 9 5 2
    list2.assign(8,1):
    The contents of list2 : 1 1 1 1 1 1 1 1
    list1.max_size(): 1073741823
    list1.size(): 4
    list1.empty(): 0
    The contents of list1 : 9 9 5 2
    The contents of list3 : 6 6 6 6 6 6 6 6 6
    list1>list3: 1
    list1<list3: 0
    The contents of list1 : 2 5 9 9
    The contents of list1 : 2 6 6 6 6 6 6 6 6 6 5 9 9
    The contents of list3 :
    Press any key to continue

# 关于堆栈 #

1.  栈

又称为堆栈,使用的是一级缓存,栈是向低地址扩展的数据结构,是一块连续的内存的区域,是数据暂时储存的地方,栈中元素个数为零时称为空栈，它是一种运算受限的线性表,**仅允许在表的一端进行插入和删除运算（遵循先进后出原则）**，此端为栈顶，另一端为栈底。向一个栈插入新元素又称作进栈，入栈或压栈，它把新元素放到栈顶元素的上面，称为栈顶元素；从一个栈删除元素又称作出栈或退栈。**由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。**

存取速度比堆要快,但存在栈中的数据大小与生存期必须是确定的，缺乏灵活性

例如: int nTest = 0;

1.  堆

堆可以被看成是**一完全二叉树**，使用的是二级缓存，需要手动分配和释放。是向高地址扩展的数据结构，**是不连续的内存区域**，它是在程序运行时而不是在程序编译时申请某个大小的内存空间。

堆没有先进后出的原则，可以随时进行增加变量和删除变量，存储速度相对慢些。

例如: char\* szTest = new char\[10\*sizeof(char)\];(记得用完要delete) ，szTest 在栈上,分配来的大小在堆区。

3.队列

队列遵循的原则是先进先出。

原文链接：https://blog.csdn.net/FEIFAZHE/article/details/89103715

在C++中，内存分成5个区，他们分别是堆、栈、自由存储区、全局/静态存储区和常量存储区。  
**栈，就是那些由编译器在需要的时候分配，在不需要的时候自动清楚的变量  
的存储区。里面的变量通常是局部变量、函数参数等**。  
堆，**就是那些由new分配的内存块**，他们的释放编译器不去管，由我们的应  
用程序去控制，一般一个new就要对应一个delete。如果程序员没有释放掉，  
那么在程序结束后，操作系统会自动回收。  
**自由存储区，就是那些由malloc等分配的内存块，他和堆是十分相似的，  
不过它是用free来结束自己的生命的。**  
全局/静态存储区，全局变量和静态变量被分配到同一块内存中，在以前的  
C语言中，全局变量又分为初始化的和未初始化的（初始化的全局变量和静态变  
量在一块区域，未初始化的全局变量与静态变量在相邻的另一块区域，同时未被  
初始化的对象存储区可以通过void\*来访问和操纵，程序结束后由系统自行释  
放），在C++里面没有这个区分了，他们共同占用同一块内存区。  
常量存储区，这是一块比较特殊的存储区，他们里面存放的是常量，不允许  
修改（当然，你要通过非正当手段也可以修改，而且方法很多）

明确区分堆与栈

我们举一个例子：

void f() {
         int* p=new int[5]; }

这条短短的一句话就包含了堆与栈，看到new，我们首先就应该想到，我们  
分配了一块堆内存，那么指针p呢？他分配的是一块栈内存，所以这句话的意思  
就是：在栈内存中存放了一个指向一块堆内存的指针p。在程序会先确定在堆中  
分配内存的大小，然后调用operator new分配内存，然后返回这块内存的首地

址，放入栈中。

堆和栈究竟有什么区别？  
主要的区别由以下几点：  
1、管理方式不同；  
2、空间大小不同；  
3、能否产生碎片不同；

4、生长方向不同；  
    
    5、分配方式不同；  
    
    6、分配效率不同；  
    管理方式：对于栈来讲，是由编译器自动管理，无需我们手工控制；对于堆

来说，释放工作由程序员控制，容易产生memory leak。  
空间大小：一般来讲在32位系统下，堆内存可以达到4G的空间，从这个角  
度来看堆内存几乎是没有什么限制的。但是对于栈来讲，一般都是有一定的空间  
大小的，例如，在VC6下面，默认的栈空间大小是1M（好像是，记不清楚了）。  
当然，我们可以修改：  
打开工程，依次操作菜单如下：Project->Setting->Link，在Category 中  
选中Output，然后在Reserve中设定堆栈的最大值和commit。  
注意：reserve最小值为4Byte；commit是保留在虚拟内存的页文件里面，它设  
置的较大会使栈开辟较大的值，可能增加内存的开销和启动时间。  
碎片问题：对于堆来讲，频繁的new/delete势必会造成内存空间的不连续，  
从而造成大量的碎片，使程序效率降低。对于栈来讲，则不会存在这个问题，因  
为栈是先进后出的队列，他们是如此的一一对应，以至于永远都不可能有一个内  
存块从栈中间弹出，在他弹出之前，在他上面的后进的栈内容已经被弹出，详细  
的可以参考数据结构，这里我们就不再一一讨论了。  
生长方向：对于堆来讲，生长方向是向上的，也就是向着内存地址增加的方  
向；对于栈来讲，它的生长方向是向下的，是向着内存地址减小的方向增长。  
分配方式：堆都是动态分配的，没有静态分配的堆。栈有2种分配方式：静  
态分配和动态分配。静态分配是编译器完成的，比如局部变量的分配。动态分配  
由alloca函数进行分配，但是栈的动态分配和堆是不同的，他的动态分配是由  
编译器进行释放，无需我们手工实现。  
分配效率：栈是机器系统提供的数据结构，计算机会在底层对栈提供支持：  
分配专门的寄存器存放栈的地址，压栈出栈都有专门的指令执行，这就决定了栈  
的效率比较高。堆则是C/C++函数库提供的，它的机制是很复杂的，例如为了分  
配一块内存，库函数会按照一定的算法（具体的算法可以参考数据结构/操作系  
统）在堆内存中搜索可用的足够大小的空间，如果没有足够大小的空间（可能是  
由于内存碎片太多），就有可能调用系统功能去增加程序数据段的内存空间，这  
样就有机会分到足够大小的内存，然后进行返回。显然，堆的效率比栈要低得多。  
从这里我们可以看到，堆和栈相比，由于大量new/delete的使用，容易造  
成大量的内存碎片；由于没有专门的系统支持，效率很低；由于可能引发用户态  
和核心态的切换，内存的申请，代价变得更加昂贵。所以栈在程序中是应用最广  
泛的，就算是函数的调用也利用栈去完成，函数调用过程中的参数，返回地址，  
EBP和局部变量都采用栈的方式存放。所以，我们推荐大家尽量用栈，而不是用  
堆。  
虽然栈有如此众多的好处，但是由于和堆相比不是那么灵活，有时候分配大  
量的内存空间，还是用堆好一些。  
无论是堆还是栈，都要防止越界现象的发生（除非你是故意使其越界），因  
为越界的结果要么是程序崩溃，要么是摧毁程序的堆、栈结构，产生以想不到的  
结果,就算是在你的程序运行过程中，没有发生上面的问题，你还是要小心，说

不定什么时候就崩掉，那时候debug可是相当困难的：）

例子：

//main.cpp 
    int a = 0; 全局初始化区 
    char *p1; 全局未初始化区 
    main() 
    {
         
    int b; 栈 
    char s[] = "abc"; 栈 
    char *p2; 栈 
    char *p3 = "123456"; 123456在常量区，p3在栈上。 
    static int c =0； 全局（静态）初始化区 
    p1 = (char *)malloc(10); 
    p2 = (char *)malloc(20); 
    分配得来得10和20字节的区域就在堆区。 
    strcpy(p1, "123456"); 123456放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。 
    }

[20200310230118331.png]: https://img-blog.csdnimg.cn/20200310230118331.png
[Animal_Cat]: https://img-blog.csdnimg.cn/20200312121743530.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzU3OTA3OQ==,size_16,color_FFFFFF,t_70