c++基础入门三

C++基础入门(三)

回顾上集，我们介绍了C++的函数重载，引用，还有内联函数，这期继续带同学们探索C嘎嘎的世界。

auto关键字

随着程序越来越复杂，使用的变量类型也越来越复杂，体现在

1、变量类型难以拼写

2、含义不明确导致容易出错

#include <string>
#include <map>
int main()
{
std::map<std::string, std::string> m{ { "apple", "苹果" }, { "orange","橙子" },{"pear","梨"} };
std::map<std::string, std::string>::iterator it = m.begin();
while (it != m.end())
{
//....
}
return 0;
}

这段代码只起到实例的作用，可以不必理会map是什么意思。其中std::map<std::string, std::string>::iterator是一个类型，非常长，同学们很容易写错，聪明的你肯定会想到用typedef来重新命名不就好了。

#include <string>
#include <map>
typedef std::map<std::string, std::string> Map;//重命名
int main()
{
Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
    //...
}

用typedef来取别名非常的方便，可以简写很多类型，但是typedef就是万能的吗。

//把char类型的指针定义成 pstring
typedef char* pstring;
int main()
{
const pstring p1; // 编译成功还是失败？
const pstring* p2; // 编译成功还是失败？
return 0;
}

在高版本的编译器VS2022会对其优化（只会显示p1没有初始化错误），如果想查看具体错误，可以在VS2019以下版本尝试.

在编程中，经常需要把表达式的值赋值给变量，赋值时我们需要清楚变量的类型，如果定义不明确，就会导致类型不匹配等错误。而想清楚知道类型不是很容易的事情，在C++11中，赋予auto新的含义

auto简介

在早期的C/C++中，auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量。但是遗憾的是，并没有多少人使用。

在C++11中，标准委员会赋予了auto新的含义：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得

int Autoint() {
return 10;
}
int main() {
int a = 10;
auto b = a;//b作为a的占位符，推导得出b是int类型，下同
auto c = 'A';
auto d = Autoint();
//auto e;//编译错误，auto使用是必须初始化
    //输出类型
cout << typeid(a).name() << endl;
cout << typeid(b).name() << endl;
cout << typeid(c).name() << endl;
cout << typeid(d).name() << endl;
return 0;
}

使用auto定义变量时必须对其进行初始化，在编译阶段编译器需要根据初始化表达式来推导auto的实际类型。因此auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型

使用细则

一、可以和指针联合使用

注意：声明指针时，auto和auto*是一样的。声明引用类型时，则必须加&

int main() {
int x = 100;
auto a = &x;
auto* b = &x;
auto& xxx = x;

cout << typeid(x).name() << endl;
cout << typeid(a).name() << endl;
cout << typeid(*b).name() << endl;
cout << typeid(xxx).name() << endl;
    
    //用指针和引用修改x的值
    *a=10;
    *b=100;
    xxx=600;
    
return 0;
}

二、在一行定义多个变量

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

int main() {

auto a = 1, b = 2, c = 3;
auto d = 1, f = 3.14, e = 2.71;//编译器报错
return 0;
}

不是相同类型，编译器报错

不能使用场景

一、不能作为函数的参数

int ADD(auto a, auto b) {
return a + b;
}

二、不能用来声明数组

int main() {
int a[] = { 1,2,3,4 };
auto b[] = { 1,2,3,4 };
return 0;
}

1、为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法

2、auto在实际中最常见的优势用法就是跟以后会讲到的C++11提供的新式for循环

基于for的循环

在C/C++98，常见的遍历数组的方式有很多种，常用的这里列出一些

int main() {
int a[] = { 1,2,3,4,5 };
//方法一
for (int i = 0; i < (sizeof(a) / sizeof(a[0])); i++)
{
cout << a[i] << endl;
}
cout << endl;
//方法二
for (int* p = a; p < a + (sizeof(a) / sizeof(a[0])); p++)
{
cout << *p << endl;
}
return 0;
}

对于一个确定范围的循环，由程序员来确定是很不友好的事情，有时候还会犯错误（数组越界等），因此在C++11中引入了一个新的功能：基于范围的for循环，for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围 。

int a[] = { 1,2,3,4,5 };
for (auto e : a) {
cout << e << endl;
}
char b[] = { 'a','b','c','d','e' };
for (auto e : b) {
cout <<e<<' ';
}

可以看见输出非常的方便。特别是和前面介绍的auto结合起来，简直是神器！

这里auto可以替换成要遍历的对应的变量类型：int/char/doubel等

使用条件

首先使用范围for的范围是要确定的，对于数组而言，就是首元素和最后一个元素的范围。对于类而言，就是begin到end的范围

下面给出错误示例

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

array数组的范围无法确定

指针空值nullptr

C++98中的指针空值NULL

在编程过程中，对一个变量赋上合适的变量是一个良好的习惯，如果赋值不合适，可能会出现无法预想的错误，例如指针未初始化（野指针），在初始指针时，对于没有指向的，我们一般都赋值为NULL

int *p=NULL;

NULL实际是个宏，在传统的C头文件(stddef.h)中，VS2022中，定义为NULL时，鼠标悬停时会显示#define NULL 0

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

void f(int)
{
cout<<"f(int)"<<endl;
}
void f(int*)
{
cout<<"f(int*)"<<endl;
}
int main()
{
    f(0);
    f(NULL);
    f((int*)NULL);
    return 0;
}

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的初衷相悖

在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0

一、使用nullptr表示空值时，不需要引入其他头文件，是C++11可直接引入的

二、在C++11中，sizeof(nullptr)和sizeof((void)*0)所占的字节大小是一样的

三、为了提高代码的健壮性，建议初始化指针时，都使用**nullptr**

原文地址：https://blog.csdn.net/sdmdnf/article/details/142346192

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！