C++细节补充

Love The Way You Lie 2021-12-18 15:07 288阅读 0赞

# 1、带参数的宏 #

关于\#define的具体用法：

\#define命令是C语言中的一个宏定义命令，它用来**将一个宏名替换为一个字符串**，该标识符被称为宏名，被定义的字符串称为替换文本。**宏定义只做字符替换，不分配内存空间。**

该命令有两种格式：一种是简单的宏定义，另一种是带参数的宏定义。

**(1)简单的宏定义：**

1.  \#define <宏名>　　<字符串>
2.  例： \#define PI 3.1415926

**(2) 带参数的宏定义**

1.  \#define <宏名> (<参数表>) <宏体>
2.  例： \#define swap(a,b)(int c;c=a;a=b;b=c;)

一个标识符被宏定义后，该标识符便是一个宏名。这时，在程序中出现的是宏名，在该程序被编译前，先将宏名用被定义的字符串替换，这称为宏替换，替换后才进行编译。

# 2、二重指针和指针引用 #

问题抛出：

在函数的使用过程中，我们都明白传值和传引用会使实参的值发生改变。那么**能够通过传指针改变指针所指向的地址吗**？

在解决这个问题之前，先了解指针非常容易混淆的属性：  
　　①.指针变量地址（&p）  
　　②.指针变量指向的地址（p，存储数据的地址）  
　　③.指针变量指向的地址的值（\*p）

指针就是存放地址的变量，可以简单的理解为： **指针就是一个地址，**

而 **指向指针的指针变量称为二级指针**。

如果p是一级指针，pp是一个二级指针，那么有如下属性：

①.（&pp）：二级指针的地址  
　　②.（pp）：二级指针指向的地址，即&p，也是传入后用到的参数  
　　③.（\*pp）：二级指针里保存的地址 ，\*pp即\*&p，也就是p，存储数据的地址  
　　④.（\*\*pp）：二级指针的地址保存的地址，该地址里面保存的地址里面的数据，即\*p，内存空间里的值

二级指针指向的地址存储的值就是一级指针指向的地址

![1657240-20190510131110574-1342810221.png][]

函数参数传递的只能是数值，所以当指针作为函数参数传递时，传递的是指针的值，而不是地址。

当指针作为函数参数传递时，在函数内部重新申请了一个新指针，与传入指针指向相同地址。在函数内部的操作只能针对指针指向的值。

#include <iostream>
    using namespace std;
     
    void pointer(int *p)
    {
        int a = 11, c = 33;
        printf("\n\nEnter function");
        printf("\nthe p is point to  %p , p's addr is %X, *p is %d", p, &p, *p);
        *p = a;
        printf("\nthe p is point to  %p , p's addr is %X, *p is %d", p, &p, *p);
        p = &c;
        printf("\nthe p is point to  %p ,  p's addr is %X, *p is %d", p, &p, *p);
     
        printf("\nfunction return\n");
    }
     
    int main()
    {
        int b = 22;
        int *p = &b;
     
        printf("the b address %X\n", &b);
        printf("the p is point to %p , p's addr is %X, *p is %d", p, &p, *p);
        pointer(p);
        printf("\nthe p is  point to %p , p's addr is %X, *p is %d\n", p, &p, *p);
    }

运行结果
    the b address 003DFC98
    the p is point to 003DFC98 , p's addr is 3DFC8C, *p is 22
     
    Enter function
    the p is point to  003DFC98 , p's addr is 3DFBB8, *p is 22//说明函数内产生了一个新的指针，和p一样指向同样的地址
    the p is point to  003DFC98 , p's addr is 3DFBB8, *p is 11
    the p is point to  003DFB98 , p's addr is 3DFBB8, *p is 33//函数内修改的都是新指针的地址
    function return
     
    the p is  point to 003DFC98 , p's addr is 3DFC8C, *p is 11//此时原来的指针p，地址不变，只改变了p指向内存的数值
    请按任意键继续. . .
    
    虽然这个指针变量名字还是叫做p，但与main函数中的指针变量已经不一样了。
    这意味着，你可以改变main函数中b的值，但是不能改变p的值。

又比如：

#include <iostream>
    using namespace std; void GetMemory(char *p, int num) { p = (char*)malloc(sizeof(char)*num); } void main() { char *s = NULL; GetMemory(s, 100); strcpy(s, "hello"); printf(s); }

GetMemory这个函数是调用malloc申请一块内存。乍一看好像没什么问题，编译也不会报错。但是运行起来，程序直接奔溃。 其实有了上面的分析就可以知道，GetMemeory中的p是不能改变s的指向的，也就是说s还是指向NULL。GetMemory中的P是临时申请的一个指针变量，当s传值进来(NULL)，时，p指向NULL，除此之外，没做任何改变。当运行malloc函数后，也只是将malloc返回的的指针地址赋给了p，并不能传递给s。所以这里就需要指针的指针（双重指针）了。

#include <iostream>
    using namespace std; void GetMemory(char **p, int num) { *p = (char*)malloc(sizeof(char)*num); } void main() { char *s = NULL; GetMemory(&s, 100); strcpy(s, "hello\n"); printf(s); }

这个时候就是将指针变量s的地址传递了过去，而不是将指针变量的值(NULL)传递了过去，因此就可以改变s的指向了。

其次，还可以用指针引用来修改指针的地址。

类似于普通变量传入变量引用，我们也传入一个指针引用，此时我们操作pp的值就是更改了p的值。

void make(int *&pp) { pp=new int(66); //试图改变p指向的地址
    } int main() { int a=5; int *p=&a; //指针变量指向一个int类型的地址
        cout<<"address:"<<&a<<" value:"<<a<<endl; cout<<"address:"<<p<<" value:"<<*p<<endl; make(p); cout<<"address:"<<p<<" value:"<<*p<<endl; }

类似的可以用二级指针修改p的内存

void make(int **pp) { int * p=new int(66); *pp=p; //二级指针的解引用被赋值需要得到一个一级指针变量，上图中二级指针的示意图中 *pp=p
    } int main() { int a=5; int *q=&a; int **pp=&q; cout<<"address:"<<&pp<<" "<<pp<<" "<<&q<<" "<<q<<" value:"        <<*q<<endl; make(pp); 　　cout<<"address:"<<&pp<<" "<<pp<<" "<<&q<<" "<<q<<" value:"<<*q<<endl; }

#  3、重载、重写和重定义 #

重载overload：是函数名相同，参数列表不同 重载只是在类的内部存在。但是不能靠返回类型来判断。

重写override：也叫做覆盖。 **子类重新定义父类中有相同名称和参数的虚函数。**函数特征相同。但是具体实现不同，主要是在继承关系中出现的 。

重写需要注意：

1 被重写的函数不能是static的。 必须是virtual的

2 重写函数必须有相同的类型，名称和参数列表

3 重写函数的访问修饰符可以不同。尽管virtual是private的，派生类中重写改写为public,protected也是可以的

重定义 (redefining)也叫做隐藏:

子类重新定义父类中有相同名称的**非虚函数** ( 参数列表可以不同 ) 。

**如果一个类，存在和父类相同的函数，那么，这个类将会覆盖其父类的方法，除非你在调用的时候，强制转换为父类类型，否则试图对子类和父类做类似重载的调用是不能成功的。**

#  4、vector和list的区别 #

**1.vector数据结构**  
vector和数组类似，拥有一段连续的内存空间，并且起始地址不变。  
因此能高效的进行随机存取，时间复杂度为o(1);  
但因为内存空间是连续的，所以在进行插入和删除操作时，会造成内存块的拷贝，时间复杂度为o(n)。  
另外，当数组中内存空间不够时，会重新申请一块内存空间并进行内存拷贝。

**2.list数据结构**  
list是由双向链表实现的，因此内存空间是不连续的。  
只能通过指针访问数据，所以list的随机存取非常没有效率，时间复杂度为o(n);  
但由于链表的特点，能高效地进行插入和删除。

#### **小结：** ####

vector拥有一段连续的内存空间，能很好的支持随机存取，  
因此vector<int>::iterator支持“+”，“+=”，“<”等操作符。

list的内存空间可以是不连续，它不支持随机访问，  
因此list<int>::iterator则不支持“+”、“+=”、“<”等

vector<int>::iterator和list<int>::iterator都重载了“++”运算符。

总之，如果需要高效的随机存取，而不在乎插入和删除的效率，使用vector;  
如果需要大量的插入和删除，而不关心随机存取，则应使用list。

# 5、C++中begin、end、front、back函数的用法 #

**一、begin函数**

**函数原型:**

**iterator begin();**

**const\_iterator begin();**

**功能：**

**返回一个当前vector容器中起始元素的迭代器。**

** **

**二、end函数**

**函数原型：**

**iterator end();**

**const\_iterator end();**

**功能：**

**返回一个当前vector容器中末尾元素的迭代器。**

** **

**三、front函数**

**函数原型：**

**reference front();**

**const\_reference front();**

**功能：**

**返回当前vector容器中起始元素的引用。**

** **

**四、back函数**

**函数原型：**

**reference back();**

**const\_reference back();**

**功能：**

**返回当前vector容器中末尾元素的引用。**

**此外，back（）还可以用于字符串类型，**

**返回字符串的最后一个字符的引用。**

** 6、std::find()**

** find函数主要实现的是在容器内查找指定的元素，并且这个元素必须是基本数据类型的。  
查找成功返回一个指向指定元素的迭代器，查找失败返回end迭代器。**

#include <iostream>
    #include <vector>
    #include <algorithm>
    using namespace std;
    int main(){
            vector<int> v;
            int num_to_find=25;//要查找的元素,类型要与vector<>类型一致
            for(int i=0;i<10;i++)
                    v.push_back(i*i);
            vector<int>::iterator iter=std::find(v.begin(),v.end(),num_to_find);//返回的是一个迭代器指针
            if(iter==v.end())
                cout<<"ERROR!"<<endl;
            else               //注意迭代器指针输出元素的方式和distance用法
                cout<<"the index of value "<<(*iter)<<" is " << std::distance(v.begin(), iter)<<std::endl;
            return 0;
    }

#  6、类型别名、别名声明、auto类型说明符、decltype类型指示符 #

某种类型的同义词，有两种方法可用于定义类型别名：

1、类型别名typedef

typedef int zhengxing；
    zhengxing i=0；

2、别名声明using

using SI = Sales_item;

3、auto类型说明符

让编译器去分析表达式所属的类型。

auto 定义变量必须有初始值。

4、decltype类型指示符

选择并返回操作符的数据类型；

基本用法：

int getSize();
    
    int main(void)
    {
        int tempA = 2;
        
        /*1.dclTempA为int*/
        decltype(tempA) dclTempA;
        /*2.dclTempB为int，对于getSize根本没有定义，但是程序依旧正常，因为decltype只做分析，并不调用getSize，*/
        decltype(getSize()) dclTempB;
    
        return 0;
    }

转载于:https://www.cnblogs.com/juanjuanduang/p/10841251.html

[1657240-20190510131110574-1342810221.png]: /images/20211218/e931de5e34ff45919c5cd5a368245950.png