C++ 拾遗 2

1.变量的作用域

1）全局变量

在整个程序生命周期内都是有效的，在定义位置之后的任意函数中都能访问。

全局变量在主程序退出时由系统收回内存空间。

2）局部变量

在函数或语句块内部的语句使用，在函数或语句块外部是不可用的。

局部变量在函数返回或语句块结束时由系统收回内存空间。

3）静态局部变量

用static修饰的局部变量生命周期和程序相同，并且只会被初始化一次。

其作用域为局部，当定义它的函数或语句块结束时，其作用域随之结束。

当程序想要使用全局变量的时候应该先考虑使用static（考虑到数据安全性）。

4）注意事项

全局变量和静态局部变量自动初始化为0。
局部变量不会自动初始化，其值是不确定的，程序中应该有初始化局部变量的代码，否则编译可能会报错（不同的编译器不一样）。
局部变量和全局变量的名称可以相同，在某函数或语句块内部，如果局部变量名与全局变量名相同，就会屏蔽全局变量而使用局部变量，如果想使用全局变量，可以在变量名前加两个冒号（::）。
for循环初始化语句中定义的变量的作用域是for语句块。

2.函数分文件编写

头文件（*.h）：需要包含的头文件，声明全局变量，函数的声明，数据结构和类的声明等。

源文件（*.cpp）：函数的定义、类的定义。

3.字符串

C++中的字符串操作可以分为两种主要风格：

C风格字符串和C++风格字符串。以下是它们的特点和常用操作，并附带相应的示例代码：

C风格字符串：

C风格字符串的本质是字符数组。
字符数组以null终止，即以\0表示字符串的结束。
在C风格字符串中，你需要手动分配内存，并负责管理字符串的长度和内存。

C++风格字符串：

C++风格字符串的本质是std::string类，它封装了字符串操作。
std::string自动管理内存，无需手动分配或释放内存。
支持丰富的字符串操作，提供更高的安全性和便捷性。

C++风格字符串的常用操作：

赋值：std::string str = "字符串内容";
拼接：str = str + "更多字符串内容";
追加：str += "追加的字符串";
长度：int length = str.length();
比较：if (str1 == str2) { /* 相等 */ } else { /* 不相等 */ }
截取子串：std::string subStr = str.substr(startIndex, length);
查找子串：size_t found = str.find("目标子串");

#include <iostream>
#include <string>int main() {// 赋值操作std::string str1 = "Hello, ";std::string str2 = "world!";// 拼接操作std::string result = str1 + str2;std::cout << "拼接后的字符串: " << result << std::endl;// 追加操作result += " Welcome to C++!";std::cout << "追加后的字符串: " << result << std::endl;// 字符串长度std::cout << "字符串长度: " << result.length() << std::endl;// 字符串比较std::string compareStr1 = "Hello, world!";std::string compareStr2 = "Welcome to C++!";if (compareStr1 == compareStr2) {std::cout << "字符串相等" << std::endl;} else {std::cout << "字符串不相等" << std::endl;}// 截取子串std::string subStr = result.substr(7, 5); // 从位置7开始截取5个字符std::cout << "截取的子串: " << subStr << std::endl;// 查找子串size_t found = result.find("C++"); // 查找C++在字符串中的位置if (found != std::string::npos) {std::cout << "子串 \"C++\" 找到，位置：" << found << std::endl;} else {std::cout << "子串 \"C++\" 未找到" << std::endl;}return 0;
}

C风格

C语言约定：如果字符型（char）数组的末尾包含了空字符\0（也就是0），那么该数组中的内容就是一个字符串。

memset(name,0,sizeof(name));   // 把全部的元素置为0。
name[0]=0;       // 不规范，有隐患，不推荐。char *strcpy(char* dest, const char* src);
功 能: 将参数src字符串拷贝至参数dest所指的地址。
返回值: 返回参数dest的字符串起始地址。
复制完字符串后，会在dest后追加0。
如果参数dest所指的内存空间不够大，会导致数组的越界。char * strncpy(char* dest,const char* src, const size_t n);
功能：把src前n个字符的内容复制到dest中。
返回值：dest字符串起始地址。
如果src字符串长度小于n，则拷贝完字符串后，在dest后追加0，直到n个。
如果src的长度大于等于n，就截取src的前n个字符，不会在dest后追加0。
如果参数dest所指的内存空间不够大，会导致数组的越界。size_t  strlen( const char*  str);
功能：计算字符串的有效长度，不包含0。
返回值：返回字符串的字符数。
strlen()函数计算的是字符串的实际长度，遇到0结束。字符串拼接strcat(）
char *strcat(char* dest,const char* src);
功能：将src字符串拼接到dest所指的字符串尾部。
返回值：返回dest字符串起始地址。
dest最后原有的结尾字符0会被覆盖掉，并在连接后的字符串的尾部再增加一个0。
如果参数dest所指的内存空间不够大，会导致数组的越界。字符串比较strcmp()和strncmp()
int strcmp(const char *str1, const char *str2 );
功能：比较str1和str2的大小。
返回值：相等返回0，str1大于str2返回1，str1小于str2返回-1；
int strncmp(const char *str1,const char *str2 ,const size_t n);
功能：比较str1和str2前n个字符的大小。
返回值：相等返回0，str1大于str2返回1，str1小于str2返回-1；
两个字符串比较的方法是比较字符的ASCII码的大小，从两个字符串的第一个字符开始，如果分不出大小，就比较第二个字符，如果全部的字符都分不出大小，就返回0，表示两个字符串相等。
在实际开发中，程序员一般只关心字符串是否相等，不关心哪个字符串更大或更小。查找字符strchr()和strrchr()
const char *strchr(const char *s, int c);
返回在字符串s中第一次出现c的位置，如果找不到，返回0。
const char *strrchr(const char *s, int c);
返回在字符串s中最后一次出现c的位置，如果找不到，返回0。查找字符串strstr()
char *strstr(const char* str,const char* substr);
功能：检索子串在字符串中首次出现的位置。
返回值：返回字符串str中第一次出现子串substr的地址；如果没有检索到子串，则返回0。

4.指针

1）指针变量

指针变量简称指针，它是一种特殊的变量，专用于存放变量在内存中的起始地址。

语法：数据类型 *变量名;

数据类型必须是合法的C++数据类型（int、char、double或其它自定义的数据类型）。

星号*与乘法中使用的星号是相同的，但是，在这个场景中，星号用于表示这个变量是指针。

2）对指针赋值

不管是整型、浮点型、字符型，还是其它的数据类型的变量，它的地址都是一个十六进制数。我们用整型指针存放整数型变量的地址；用字符型指针存放字符型变量的地址；用浮点型指针存放浮点型变量的地址，用自定义数据类型指针存放自定义数据类型变量的地址。

语法：指针=&变量名;

注意

对指针的赋值操作也通俗的被称为“指向某变量”，被指向的变量的数据类型称为“基类型”。
如果指针的数据类型与基类型不符，编译会出现警告。但是，可以强制转换它们的类型。

3）指针占用的内存

指针也是变量，是变量就要占用内存空间。

在64位的操作系统中，不管是什么类型的指针，占用的内存都是8字节。

在C++中，指针是复合数据类型，复合数据类型是指基于其它类型而定义的数据类型，在程序中，int是整型类型，int*是整型指针类型，int*可以用于声明变量，可以用于sizeof运算符，可以用于数据类型的强制转换，总的来说，把int*当成一种数据类型就是了。

4）使用指针

声明指针变量后，在没有赋值之前，里面是乱七八糟的值，这时候不能使用指针。

指针存放变量的地址，因此，指针名表示的是地址（就像变量名可以表示变量的值一样）

*运算符被称为间接值或解除引用（解引用）运算符，将它用于指针，可以得到该地址的内存中存储的值，*也是乘法符号，C++根据上下文来确定所指的是乘法还是解引用。

5）指针用于函数的参数

如果把函数的形参声明为指针，调用的时候把实参的地址传进去，形参中存放的是实参的地址，在函数中通过解引用的方法直接操作内存中的数据，可以修改实数的值，这种方法被通俗的称为地址传递或传地址。

值传递：函数的形参是普通变量。

传地址的意义如下：

可以在函数中修改实参的值。
减少内存拷贝，提升性能。

6）const 修饰指针

语法：const 数据类型 *变量名;（左定值）

不能通过解引用的方法修改内存地址中的值（用原始的变量名是可以修改的）。

注意：

指向的变量（对象）可以改变（之前是指向变量a的，后来可以改为指向变量b）。
一般用于修饰函数的形参，表示不希望在函数里修改内存地址中的值。
如果用于形参，虽然指向的对象可以改变，但这么做没有任何意义。

如果形参的值不需要改变，建议加上const修饰，程序可读性更好。

语法：数据类型 * const 变量名;

指向的变量（对象）不可改变。

注意：

在定义的同时必须初始化，否则没有意义。
可以通过解引用的方法修改内存地址中的值。

C++编译器把指针常量做了一些特别的处理，改头换面之后，有一个新的名字，叫引用。

7）空指针

如果对空指针解引用，程序会崩溃。

如果对空指针使用delete运算符，系统将忽略该操作，不会出现异常。所以，内存被释放后，也应该把指针指向空。

在函数中，应该有判断形参是否为空指针的代码，目的是保证程序的健壮性。

为什么空指针访问会出现异常？

NULL指针分配的分区：其范围是从 0x00000000到0x0000FFFF。这段空间是空闲的，对于空闲的空间而言，没有相应的物理存储器与之相对应，所以对这段空间来说，任何读写操作都是会引起异常的。空指针是程序无论在何时都没有物理存储器与之对应的地址。为了保障“无论何时”这个条件，需要人为划分一个空指针的区域，固有上面NULL指针分区。

8）野指针

野指针就是指针指向的不是一个有效（合法）的地址。

在程序中，如果访问野指针，可能会造成程序的崩溃。

出现野指针的情况主要有三种：

1）指针在定义的时候，如果没有进行初始化，它的值是不确定的（乱指一气）。

2）如果用指针指向了动态分配的内存，内存被释放后，指针不会置空，但是，指向的地址已失效。

3）指针指向的变量已超越变量的作用域（变量的内存空间已被系统回收），让指针指向了函数的局部变量，或者把函数的局部变量的地址作为返回值赋给了指针。

规避方法：

1）指针在定义的时候，如果没地方指，就初始化为nullptr。

2）动态分配的内存被释放后，将其置为nullptr。

3）函数不要返回局部变量的地址。

注意：野指针的危害比空指针要大很多，在程序中，如果访问野指针，可能会造成程序的崩溃。是可能，不是一定，程序的表现是不稳定，增加了调试程序的难度。

4.void关键字

在C++中，void表示为无类型，主要有三个用途：

1）函数的返回值用void，表示函数没有返回值。

void func(int a,int b)

{

// 函数体代码。

return;

}

2）函数的参数填void，表示函数不需要参数（或者让参数列表空着）。

int func(void)

{

// 函数体代码。

return 0;

}

3）的形参用void *，表示接受任意数据类型的指针。

注意：

不能用void声明变量，它不能代表一个真实的变量，但是，用void *可以。
不能对void *指针直接解引用（需要转换成其它类型的指针）。
把其它类型的指针赋值给void*指针不需要转换。
把void *指针赋值给把其它类型的指针需要转换。

5.动态内存分配

使用堆区的内存有四个步骤：

1）声明一个指针；

2）用new运算符向系统申请一块内存，让指针指向这块内存；

3）通过对指针解引用的方法，像使用变量一样使用这块内存；

4）如果这块内存不用了，用delete运算符释放它。

申请内存的语法：new 数据类型(初始值); // C++11支持{}

如果申请成功，返回一个地址；如果申请失败，返回一个空地址（暂时不考虑失败的情况）。

释放内存的语法：delete 地址;

释放内存不会失败（还钱不会失败）。

动态分配出来的内存没有变量名，只能通过指向它的指针来操作内存中的数据。
如果动态分配的内存不用了，必须用delete释放它，否则有可能用尽系统的内存。
动态分配的内存生命周期与程序相同，程序退出时，如果没有释放，系统将自动回收。
就算指针的作用域已失效，所指向的内存也不会释放。
用指针跟踪已分配的内存时，不能跟丢。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。int main()
{// 1）声明一个指针；// 2）用new运算符向系统申请一块内存，让指针指向这块内存；// 3）通过对指针解引用的方法，像使用变量一样使用这块内存；// 4）如果这块内存不用了，用delete运算符释放它。// 申请内存的语法：new 数据类型(初始值);   // C++11支持{}// 释放内存的语法：delete 地址;int* p = new int(5);cout << "*p=" << *p << endl;*p = 8;cout << "*p=" << *p << endl;delete p;/*	for (int ii = 1; ii > 0; ii++){int* p = new int[100000];     // 一次申请100000个整数，这个语法以后再讲。cout << "ii="<<ii<<",p=" << p << endl;}/*
}

6.一维指针和数组

1）指针的算术

将一个整型变量加1后，其值将增加1。

但是，将指针变量（地址的值）加1后，增加的量等于它指向的数据类型的字节数。

2）数组的地址

a）数组在内存中占用的空间是连续的。

b）C++将数组名解释为数组第0个元素的地址。

c）数组第0个元素的地址和数组首地址的取值是相同的。

d）数组第n个元素的地址是：数组首地址+n

e）C++编译器把数组名[下标] 解释为 *(数组首地址+下标)

3）数组的本质

数组是占用连续空间的一块内存，数组名被解释为数组第0个元素的地址。C++操作这块内存有两种方法：数组解释法和指针表示法，它们是等价的。

4）数组名不一定会被解释为地址

在多数情况下，C++将数组名解释为数组的第0个元素的地址，但是，将sizeof运算符用于数据名时，将返回整个数组占用内存空间的字节数。

可以修改指针的值，但数组名是常量，不可修改。

5）用new动态创建

普通数组在栈上分配内存，栈很小；如果需要存放更多的元素，必须在堆上分配内存。

动态创建一维数组的语法：数据类型 *指针=new 数据类型[数组长度];

释放一维数组的语法：delete [] 指针;

注意：

动态创建的数组没有数组名，不能用sizeof运算符。
可以用数组表示法和指针表示法两种方式使用动态创建的数组。
必须使用delete[]来释放动态数组的内存（不能只用delete）。
不要用delete[]来释放不是new[]分配的内存。
不要用delete[]释放同一个内存块两次（否则等同于操作野指针）。
对空指针用delete[]是安全的（释放内存后，应该把指针置空nullptr）。
声明普通数组的时候，数组长度可以用变量，相当于在栈上动态创建数组，并且不需要释放。
如果内存不足，调用new会产生异常，导致程序中止；如果在new关键字后面加(std::nothrow)选项，则返回nullptr，不会产生异常。
为什么用delete[]释放数组的时候，不需要指定数组的大小？因为系统会自动跟踪已分配数组的内存。

6）数组排序

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。int compasc(const void* p1, const void* p2)         // 升序的回调函数。
{return *((int*)p1) - *((int*)p2);
}int compdesc(const void* p1, const void* p2)       // 降序的回调函数。
{return *((int*)p2) - *((int*)p1);
}int main()
{int a[8] = { 4,2,7,5,8,6,1,3 };qsort(a,sizeof(a)/sizeof(int),sizeof(int),compasc);                   // 对数组a进行升序排序。for (int ii = 0; ii < 8; ii++){cout << "a[" << ii << "]=" << a[ii] << endl;}qsort(a, sizeof(a) / sizeof(int), sizeof(int), compdesc);            // 对数组a进行降序排序。for (int ii = 0; ii < 8; ii++){cout << "a[" << ii << "]=" << a[ii] << endl;}
}