【C++从练气到飞升】01---C++入门

 🎈个人主页:库库的里昂
收录专栏:C++从练气到飞升
🎉鸟欲高飞先振翅,人求上进先读书。

目录

推荐

前言

什么是C++

C++的发展史

📋命名空间

命名空间定义

命名空间使用

命名空间的嵌套

std命名空间的使用

📋C++输入&输出

缺省参数的定义

缺省参数分类

缺省参数出现的位置

📋函数重载

函数重载的概念

函数重载的种类

C++支持函数重载的原理

📋引用

引用的概念

引用的特性

引用的使用场景

传值和引用性能比较

常引用

引用和指针的区别 

📋内联函数

内联函数的概念

内联函数的特征

📋auto关键字

auto简介

auto使用规则

auto无法使用的场景

📋基于范围的for循环

范围for的语法

范围for的使用条件

📋指针空值nullptr


⛳️推荐

前些天发现了一个巨牛的人工智能学习网站,通俗易懂,风趣幽默,忍不住分享一下给大家。点击跳转到网站

前言

什么是C++

        C语言是结构化和模块化的语言,适合处理较小规模的程序。对于复杂的问题,规模较大的程序,需要高度的抽象和建模时,C语言则不合适。为了解决软件危机, 20世纪80年代, 计算机界提出了OOP(object oriented programming:面向对象)思想,支持面向对象的程序设计语言应运而生。
        1982年,Bjarne Stroustrup博士在C语言的基础上引入并扩充了面向对象的概念,发明了一种新的程序语言。为了表达该语言与C语言的渊源关系,命名为C++。因此:C++是基于C语言而产生的,它既可以进行C语言的过程化程序设计,又可以进行以抽象数据类型为特点的基于对象的程序设计,还可以进行面向对象的程序设计。

C++的发展史

        1979年,贝尔实验室的本贾尼等人试图分析unix内核的时候,试图将内核模块化,于是在C语言的基础上进行扩展,增加了类的机制,完成了一个可以运行的预处理程序,称之为C with classes。

语言的发展就像是练功打怪升级一样,也是逐步递进,由浅入深的过程。我们先来看下C++的历史版本。

C++还在不断的向后发展。但是:现在公司主流使用还是C++98和C++11,所有大家不用追求最新,重点将C++98和C++11掌握好,等工作后,随着对C++理解不断加深,有兴趣的小伙伴可以去琢磨下更新的特性。

📋命名空间

在C/C++中,变量、函数和后面要学到的类都是大量存在的,这些变量、函数和类的名称将都存在于全局作用域中,可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化,以避免命名冲突或名字污染,namespace关键字的出现就是针对这种问题的。

#include <stdio.h>
#include <stdlib.h>int rand = 10;// C语言没办法解决类似这样的命名冲突问题,所以C++提出了namespace来解决
int main()
{printf("%d\n", rand);return 0;
}// 编译后后报错:error C2365: “rand”: 重定义;以前的定义是“函数”
命名空间定义

命名空间的定义由两部分构成:首先是关键字namespace,后面跟命名空间的名字,然后接一对{},{}中即为命名空间的成员。 命名空间中可以定义变量、函数、类型和其他命名空间。

namespace N1//命名空间的名字
{//定义变量int rand = 10;//定义函数int Add(int left, int right){return left + right;}//定义类型struct Node{struct Node* next;int val;};//嵌套命名空间namespace N2{int Sub(int left, int right){return left - right;}}
}

注意:

  • 一个命名空间就定义了一个新的作用域,命名空间中的所有内容都局限于该命名空间中。
  • 用一个工程中允许出现多个相同名称的命名空间,编译器最后会将它们合并为一个命名空间
命名空间使用

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

  • 加命名空间名称及域作用限定符
namespace N
{int a=10;int b=5;
}int main()
{printf("%d\n", N::a);return 0;    
}
  • 使用 using 将命名空间中某个成员引入
using N::b;
int main()
{printf("%d\n", N::a);printf("%d\n", b);return 0;    
}
  • 使用 using namespace 命名空间名称引入(展开命名空间)
namespace N
{int a=10;int b=5;
}int a=20;using namespce N;int main()
{printf("%d\n", a);      //a不明确,有二义性printf("%d\n", ::a);    //访问全局的a  printf("%d\n", N::a);   //访问N中的aprintf("%d\n", b);return 0;    
}

N中的成员a 就与全局作用域中的a 产生了冲突。这种冲突是允许存在的,但是要想使用冲突的名字,我们就必须明确指出名字的版本。main函数中所有未加限定的a都会产生二义性错误。

这时我们必须使用域作用限定符(::)来明确指出所需的版本

  • : :a来表示全局作用域中的a
  • N: :a来表示定义在N中的a

注意:

如果命名空间没有展开,编译器默认是不会搜索命名空间中的变量,去访问变量是访问不到的。

访问的优先级:局部域 > 全局域

命名空间的嵌套

嵌套的命名空间同时是一个嵌套的作用域,它嵌套在外层命名空间的作用域中。嵌套的命名空间中的名字遵循的规则与往常类似:内层命名空间声明的名字将隐藏外层命名空间声明的同名成员。在嵌套的命名空间中定义的名字只在内层命名空间中有效,外层命名空间的代码想要访问它必须在名字前添加限定符。

namespace N
{int a = 10;namespace N1{int a = 20;    //将外层作用域的a隐藏了int b = 15;namespace N2{int c = N1::b;}
}int main()
{printf("%d\n", N::N2::c);printf("%d\n", N::N1::a);printf("%d\n", N::a);return 0;
}
std命名空间的使用

std是C++标准库的命名空间,如何展开std使用更合理呢?

  1. 在日常练习中,建议直接using namespace std;即可,这样就很方便。
  2.  using namespace std;展开,标准库就全部暴露出来了,如果我们定义跟库重名的类型、对象、函数,就存在冲突问题。该问题在日常练习中很少出现,但是项目开发中代码较多、规模 大,就很容易出现。所以建议在项目开发中使用,像std::cout这样使用时指定命名空间例如: using std::cout展开常用的库对象、类型等方式。 

📋C++输入&输出

#include <iostream>
using namespace std;int main()
{int a = 10;double b = 10.5;cout << a << endl;cout << b << endl;return 0;
}

我们在项目中要经常使用 cout 和 endl,每次指定命名空间很不方便,直接展开会全部暴露,有冲突风险,我们可以指定展开来解决问题。

using std::cout;
using std::endl;

说明:

  • 使用cout标准输出对象(控制台)cin标准输入对象(键盘)时,必须包含< iostream >头文件以及按命名空间使用方法使用std。
  • cout 和 cin 是全局的流对象,endl 是特殊的C++符号,表示换行输出,他们都包含在包含 < iostream >头文件中。
  • <<是流插入运算符,>>是流提取运算符。
  • 使用C++输入输出更方便,不需要像 printf和scanf 输入输出时那样,需要手动控制格式。 C++的输入输出可以自动识别变量类型。

📋缺省参数

缺省参数的定义

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

void Func(int a = 5)
{cout << a << endl;
}int main()
{Func();     // 没有传参时,使用参数的默认值Func(10);   // 传参时,使用指定的实参return 0;
}

上面代码在第一次调用 Func() 时,没有传递参数,a 就使用了缺省值。

缺省参数分类
  • 全缺省参数 -- 所有参数都给了缺省值
void Func(int a = 10, int b = 20, int c = 30)
{cout<<"a = "<<a<<endl;cout<<"b = "<<b<<endl;cout<<"c = "<<c<<endl;
}int main()
{Func(1,2,3);    Func(1,2); Func(1); Func();  return 0;
}

全缺省参数在传参时,参数是按照从左往右的顺序进行缺省的,不能跳着缺省,例如:Func(1,  ,3) ,让第一个形参和第三个形参都使用传递值,而让第二个参数使用缺省值,这种做法是不被允许的。

  • 半缺省参数 -- 部分的参数给了缺省值
void Func(int a, int b = 20, int c = 30)
{cout<<"a = "<<a<<endl;cout<<"b = "<<b<<endl;cout<<"c = "<<c<<endl;
}int main()
{Func(1,2,3);    Func(1,2); Func(1);  return 0;
}

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

注意:

  1. 缺省参数不能在函数声明和定义中同时出现,只能出现在函数声明中。
  2. 缺省值必须是常量或者全局变量。
缺省参数出现的位置

      缺省参数只能出现在函数声明中,如下面的代码,在声明和定义中都给了缺省参数,而且给定的值不相同,就不知道以哪个值为准。

//a.h
void Func(int a = 10);//a.cpp
void Func(int a = 20)
{}

不能只在声明处给缺省参数,如下面的代码,如果只在声明处给缺省参数,在其他的文件中没有缺省参数,就不知是什么值。

//a.cpp
void Func(int a = 10)
{}//b.cpp
void Func(int a)
{}

📋函数重载

     自然语言中,一个词可以有多重含义,人们可以通过上下文来判断该词真实的含义,即该词被重载了。 比如:以前有一个笑话,国有两个体育项目大家根本不用看,也不用担心。一个是乒乓球,一个 是男足。前者是“谁也赢不了!”,后者是“谁也赢不了!”

函数重载的概念

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

函数重载的种类
  • 参数类型不同
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;
}int main()
{cout << Add(1, 2) << endl;cout << Add(1.0, 2.0) << endl;
}

上面的代码定义了两个同名的Add函数,但是它们的参数类型不同,第一个函数的两个参数都是int型,第二个函数的两个参数都是double型,在调用Add函数的时候,编译器会根据所传实参的类型自动判断调用哪个函数。

  • 参数个数不同
void Fun()
{cout << "f()" << endl;
}void Fun(int a)
{cout << "f(int a)" << endl;
}int main()
{Fun();Fun(1);return 0;
}

  • 参数类型顺序不同
void Text(int a, char b)
{cout << "Text(int a,char b)" << endl;
}void Text(char b, int a)
{cout << "Text(char b, int a)" << endl;
}int main()
{Text(1, 'a');Text('a', 1);return 0;
}
  • 有缺省参数的情况
void Fun()
{cout << "f()" << endl;
}void Fun(int a = 10)
{cout << "f(int a)" << endl;
}int main()
{Fun();     //无参调用会出现歧义Fun(1);    //调用的是第二个return 0;
}

上面代码中的两个Fun函数构成函数重载,编译可以通过,因为第一个没有参数,第二个有一个整型参数,属于上面的参数个数不同的情况。但是Fun函数存在一个问题:在没有参数调用的时候会产生歧义,因为有缺省参数,所以对两个Fun函数来说,都可以不传参。

注意:返回值的类型与函数是否构成重载无关。

C++支持函数重载的原理

     在C/C++中,一个程序要运行起来,需要经历以下几个阶段:预处理、编译、汇编、链接。

我们想理解清楚函数重载,还要了解函数签名的概念,函数签名包含了一个函数的信息,包括函数名、它的参数类型、他所在的类和名称空间以及其他信息。函数签名用于识别不同的函数。 C++编译器和链接器都使用符号来标识和处理函数和变量,所以对于不同函数签名的函数,即使函数名相同,编译器和链接器都认为他们是不同的函数。

Linux环境下采用C语言编译器编译后结果

可以看出经过gcc编译后,函数名字的修饰没有发生改变。这也就是为什么C语言不支持函数重
载,因为同名函数没办法区分。

采用C++编译器编译后结果

其中_Z是固定的前缀;3表示函数名的长度;Add就是函数名;i是int的缩写,两个i表示两个参数都是int类型,d是double的缩写,两个d表示两个参数都是double类型。C++就是通过函数修饰规则来区分,只要参数不同,修饰出来的名字就不一样,就支持了重载。通过分析可以发现,修饰后的名称中并不包含任何于函数返回值有关的信息,因此也验证了上面说的返回值的类型与函数是否构成重载无关。

总结:

  1. C语言之所以没办法支持重载,是因为同名函数没办法区分。而C++是通过函数修饰规则来区分,只要参数不同,修饰出来的名字就不一样,就支持了重载。
  2. 如果两个函数函数名和参数是一样的,返回值不同是不构成重载的,因为调用时编译器没办法区分。

📋引用

引用的概念

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

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

int main()
{int a = 0;int& b = a;//定义引用类型,b是a的引用return 0;
}

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

引用的特性
  • 引用在定义时必须初始化
int main()
{int a = 10;int& b;    //错误的return 0;
}

在使用引用时,我们必须对变量进行初始化。int& b = a;,这样的代码才是被允许的。

  • 引用不能改变指向
int main()
{int a = 10;int b = 20;int& c = a;c = b;return 0;
}

我们可以看到b和c的地址不同,所以c = b表示的不是c是b引用,而是是把b变量的值赋值给c引用的实体,c依旧是a的引用,所以引用一旦引用一个实体,再不能引用其他实体,也就是引用不能改变指向。

引用的使用场景

🎀做参数

引用做参数的意义:

  • 做输出型参数,即要求形参的改变可以影响实参
  • 提高效率,自定义类型传参,用引用可以避免拷贝构造,尤其是大对象和深拷贝对象

交换两个整型变量: 

void Swap(int& num1, int& num2)
{int tmp = num1;num1 = num2;num2 = tmp;
}int main()
{int a = 5;int b = 10;Swap(a,b);return 0;
}

如上代码,我们可以使用引用做参数实现了两个数的交换,num1是 a 的引用,和 a 在同一块空间,对num1的修改也就是对 a 修改, b 同理,所以在函数体内交换num1和num2实际上就是交换 a 和 b 。以前交换两个数的值,我们需要传递地址,还要进行解引用,相对繁琐。

交换两个指针变量:

void Swap(int*& p1, int*& p2)
{int* tmp = p1;p1 = p2;p2 = tmp;
}int main()
{int a = 5;int b = 10;int* pa = &a;int* pb = &b;Swap(pa,pb);return 0;
}

如果用C语言来实现交换两个指针变量,实参需要传递指针变量的地址,那形参就需要用二级指针来接收,这显然十分容易出错。有了引用之后,实参直接传递指针变量即可,形参用指针类型的引用。

🎀做返回值

引用做返回值的意义:

  • 减少拷贝,提高效率。
  • 可以同时读取和修改返回对象
int& add(int x, int y)
{int sum = x + y;return sum;
}int main()
{int a = 5;int b = 10;int ret = add(a, b);cout << ret << endl;return 0;
}

如上代码,我们使用传值返回,调用函数要创建栈帧,sum是add函数中的一个局部变量,存储在当前函数的栈帧中,函数调用结束栈帧销毁,sum也会随之销毁,对于这种传值返回,会生成一个临时的中间变量,用来存储返回值,在返回值比较小的情况下,这个临时的中间变量一般就是寄存器。

如上代码,传引用就是给sum起了一个别名,返回的值就是sum的别名,但是这里会出现问题,函数调用结束栈帧销毁,sum也会随之销毁,返回它的值再进行调用就是越界访问,打印出的值为随机值。

可是这里的值为什么是正确的呢?这是取决于编译器的,看编译器是否会对这块空间进行清理。

传值和引用性能比较

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

struct A
{int a[100000];
};void TestFunc1(A a)
{;
}void TestFunc2(A& a)
{;
}void TestFunc3(A* a)
{;
}//引用传参————可以提高效率(大对象或者深拷贝的类对象)
void TestRefAndValue()
{A a;// 以值作为函数参数size_t begin1 = clock();for (size_t i = 0; i < 10000; ++i)//就是单纯的调用一万次这个函数传一万次参TestFunc1(a);size_t end1 = clock();// 以引用作为函数参数size_t begin2 = clock();for (size_t i = 0; i < 10000; ++i)TestFunc2(a);//这里直接传的是变量名size_t end2 = clock();//以指针作为函数参数size_t begin3 = clock();for (int i = 0; i < 10000; i++){TestFunc3(&a);}size_t end3 = clock();// 分别计算两个函数运行结束后的时间cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;cout << "TestFunc3(A*)-time:" << end3 - begin3 << endl;
}

值和引用的作为返回值类型的性能比较:

struct A
{int a[100000];
};
A a;//全局的,函数栈帧销毁后还在// 值返回
A TestFunc1()
{return a;
}// 引用返回
A& TestFunc2()
{return a;
}
void TestReturnByRefOrValue()
{// 以值作为函数的返回值类型size_t begin1 = clock();for (size_t i = 0; i < 100000; ++i)TestFunc1();//就让他返回不接收size_t end1 = clock();// 以引用作为函数的返回值类型size_t begin2 = clock();for (size_t i = 0; i < 100000; ++i)TestFunc2();size_t end2 = clock();// 计算两个函数运算完成之后的时间cout << "TestFunc1 time:" << end1 - begin1 << endl;cout << "TestFunc2 time:" << end2 - begin2 << endl;
}int main()
{TestReturnByRefOrValue();return 0;
}

常引用

🎀 权限放大

int main()
{const int a = 10;int& b = a;return 0;
}

       上面代码中,用const定义了一个常变量 a ,然后给a取一个别名 b ,这段代码在编译过程中出现了错误,这是为什么呢?

      a 是一个常变量,是不可以被修改的,给 a 取别名为变量 b ,变量b没有用const修饰,所以不具有常属性,是可以被修改的,相当于权限的放大,这种情况是不允许的。正确的做法是:

int main()
{const int a = 10;const int& b = a;return 0;
}

🎀 权限缩小

int main()
{int a = 10;const int& b = a;return 0;
}

        上面代码中,给一个普通的变量a取了一个别名b,这个b是一个常引用。这意味着,可以通过a变量去对内存中存储的数据进行修改,但是不能通过b去修改内存中存储的数据,但是b会跟着变。

引用和指针的区别 
  • 引用在概念上定义一个变量的别名,指针存储一个变量的地址
  • 引用在定义时必须初始化,指针没有要求。
  • 引用在初始化时引用一个一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型实体。
  • 没有NULL引用,但有NULL空指针。
  • 在sizeof中的含义不同,引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位机下占四个字节,64位机下占八个字节)。
  • 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小。
  • 有多级指针,但是没多级引用
  • 访问实体方式不同。指针显式解引用,引用编译器自己做处理。
  • 引用比指针使用起来相对更安全。

📋内联函数

     普通的函数在调用的时候会开辟函数栈帧,会产生一定量的消耗,在C语言中可以用宏函数来解决这个问题,但是宏存在以下缺陷:复杂、容易出错、可读性差、不能调试。为此,C++中引入了内联函数这种方法。.

内联函数的概念

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

int Add(int x, int y)
{return x + y ;
}int main()
{int ret = 0;ret = Add(3, 5);cout << ret << endl;return 0;
}

🎀内联函数

inline int Add(int x, int y)
{return x + y ;
}

内联函数在编译期间编译器会用函数体替换函数的调用。

注意:在默认的Debug模式下,内联函数是不会展开的。

查看方式:

  • 在release模式下,查看编译器生成的汇编代码中是否存在call Add。
  • 在debug模式下,需要对编译器进行设置,否则不会展开,需要进行设置,设置过程如下:

内联函数的特征
  1. inline是一种以空间换时间的做法,如果编译器将函数当成内联函数处理,在编译阶段,会用函数体替换函数调用,缺陷:可能会使目标文件变大,优势:少了调用开销,提高程序运行效率。 
  2. inline对于编译器而言只是一个建议,不同编译器关于inline实现机制可能不同,一般建议:将函数规模较小(即函数不是很长,具体没有准确的说法,取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰,否则编译器会忽略inline特性。
  3. inline不建议声明和定义分离,分离会导致链接错误。因为inline被展开,就没有函数地址 了,链接就会找不到。

📋auto关键字

         随着程序越来越复杂,程序中用到的类型也越来越复杂,例如:

#include <vector>
#include <string>int mian()
{vetcor<string> v;vetcor<string>::iterator it = v.begin();return 0;
}

 vetcor<string>::iterator是一个类型,但是该类型太长了,特别容易写错。在C语言中,我们可以通过 typedef 给类型取别名,比如:

typedef vetcor<string>::iterator Map;

使用 typedef 给类型取别名确实可以简化代码,但使用 typedef 又会遇到新的问题。在编程时,常常需要把表达式的值赋值给变量,这就要求在声明变量的时候清楚地知道表达式的类型。但这点有时很难做到,因此C++11给auto赋予了新的含义。

auto it = v.degin();
auto简介

在早期C/C++中auto的含义是:使用auto修饰的变量,是具有自动存储器的局部变量, 但在C++11中:auto不再是一个存储类型指示符,而是作为一个新的类型指示符来指示编译器,auto声明的变量必须由编译器在编译时期推导而得。简单来说,auto会根据表达式自动推导类型

int main()
{int a = 0;auto b = a;auto& c = a;auto* d = &a;//typeid可用来查看变量类型cout << typeid(b).name() << endl;cout << typeid(c).name() << endl;cout << typeid(d).name() << endl;return 0;
}

注意:

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

int main()
{auto a;    //要初始化return 0;
}

auto使用规则

🎀auto与指针和引用结合起来使用

  • 用auto声明指针类型时,用auto和auto*没有任何区别
int main()
{int x = 10;auto a = &x;auto* b = &x;cout << typeid(a).name() << endl;cout << typeid(b).name() << endl;return 0;
}

  • 用auto声明引用类型时,则必须加&
int main()
{int x = 10;auto& a = x;cout << typeid(a).name() << endl;return 0;
}

🎀在同一行定义多个变量 

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

int main()
{auto a = 10, b = 30;auto c = 15, d = 1.5;//该行编译失败,c和d的初始化类型不同
}
auto无法使用的场景

🎀auto不能作为函数的参数

//错误,编译器无法对x的实际类型进行推导
void Text(auto x)
{}int main()
{int a=5;Test(a);return 0;
}

🎀auto不能作返回值

auto Test(int x)
{}

🎀auto不能直接用来声明数组

void Text()
{auto arr[] = { 1, 2, 3 };//错误写法int arr[] = {1, 2, 3}//这才是正确写法
}

📋基于范围的for循环

范围for的语法

     我们在以前使用 for 遍历一个数组,会用下面这种方法:

int main()
{int arr[] = { 1,2,3,4,5 };int size = sizeof(arr) / sizeof(arr[0]);for (int i = 0; i < size; ++i){cout << arr[i] << " ";}cout << endl;
}

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

int main()
{int arr[] = { 1,2,3,4,5 };int size = sizeof(arr) / sizeof(arr[0]);for (auto e : arr){cout << e << " ";}return 0;
}

依次取数组arr中的每个数赋值给e,e也就是数组中每个数的拷贝,所以e的改变不会影响数组中数的改变,想要改变数组的值,要使用引用。

int main()
{int arr[] = { 1,2,3,4,5 };int size = sizeof(arr) / sizeof(arr[0]);for (auto e : arr){e++;cout << e << " ";}cout << endl;for (auto e : arr){cout << e << " ";}return 0;
}

范围for的使用条件
  1. for循环迭代的范围必须是确定的
  2. 迭代的对象要实现++和==的操作

对于数组而言,就是数组中第一个元素和最后一个元素的范围;对于类而言,应该提供 begin 和end的方法,begin和end就是for循环迭代的范围。

注意:以下代码就有问题,因为for的范围不确定 

void Text(int arr[])//arr本质上只是一个地址,没有范围
{for (auto a : arr){cout << a << endl;}
}

数组不能传参,数组传参传递的是数组首元素的地址

📋指针空值nullptr

     在C/C++编程习惯中,我们声明一个变量时最好给该变量一个合适的初始值,否则可能会出现 不可预料的错误,比如未初始化的指针。如果一个指针没有合法的指向,我们都会把它置为空指针。

void Test()
{int* p1 = NULL;int* p2 = 0;
}

 NULL实际是一个宏,在传统的C头文件(stddef.h)中,可以看到如下代码:

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

下面这段代码的结果是什么呢?

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

程序本意是想通过 f(NULL) 调用 f(int*) 函数,但是由于NULL被定义成0,因此与程序的初衷相悖。 在C++98中,字面常量0既可以是一个整形数字,也可以是无类型的指针(void*)常量,但是编译器默认情况下将其看成是一个整形常量,如果要将其按照指针方式来使用,必须对其进行强转(void *)0。 

注意:

  1.  在使用nullptr表示指针空值时,不需要包含头文件,因为nullptr是C++11作为新关键字引入的。
  2.  在C++11中,sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。
  3. 为了提高代码的健壮性,在后续表示指针空值时建议最好使用nullptr。

本次的内容到这里就结束啦。希望大家阅读完可以有所收获,同时也感谢各位读者三连支持。文章有问题可以在评论区留言,博主一定认真认真修改,以后写出更好的文章。你们的支持就是博主最大的动力。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/271232.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

离散数学例题——4.计数和集合论(特殊关系、计数基础和函数)

等价关系 等价关系的证明 等价类和商集 等价关系与划分一一对应 偏序关系 证明偏序关系 哈斯图 整除关系画哈斯图 特殊元素 最大最小元&#xff0c;极大极小元 上界上确界&#xff0c;下界下确界 其他关系 全序关系、良序关系 拟序关系、相容关系 计数基础 排列组合 函数定义…

Chromium内核浏览器编译记(四)Linux版本CEF编译

转载请注明出处&#xff1a;https://blog.csdn.net/kong_gu_you_lan/article/details/136508294 本文出自 容华谢后的博客 0.写在前面 本篇文章是用来记录编译Linux版本CEF的步骤和踩过的坑&#xff0c;以防止后续再用到的时候忘记&#xff0c;同时也希望能够帮助到遇到同样问…

离散数学例题——5.图论基础

基本的图 关联矩阵 子图和补图 度数和握手定理 注意&#xff01;&#xff01;&#xff01;无向图的度数&#xff0c;要行/列和对角线值 根据度数序列判定是否为无向图 度和握手定理证明题 竞赛图 同构图 自补图 通路和回路数量 通路和回路数量 最短路径——dijkstra算法 连通…

[数据结构初阶]队列

鼠鼠我呀&#xff0c;今天写一个基于C语言关于队列的博客&#xff0c;如果有兴趣的读者老爷可以抽空看看&#xff0c;很希望的到各位老爷观点和点评捏&#xff01; 在此今日&#xff0c;也祝各位小姐姐女生节快乐啊&#xff0c;愿笑容依旧灿烂如初阳&#xff0c;勇气与童真永不…

【HTML】HTML基础7.2(有序列表)

目录 标签 效果 注意 标签 <ol> <li>列表内容</li> <li>列表内容</li> <li>列表内容</li> <li>列表内容</li> 。。。。。。 </ol> 效果 代码 <ol><li>银河护卫队 10000000000</li><l…

RUST 每日一省:发布到crates.io

github是开源代码分享的地方&#xff0c;rust的开源项目除了github&#xff0c;我们还可以将其发布到 crates.io 上&#xff0c;然后其它用户就可以使用cargo进行安装使用了。其实步骤很简单&#xff0c;只有三条命令了&#xff0c;我们一次来看一下。 1、cargo package 首先&a…

Threejs着色器(GPU)编程——感温管网

管网,作为支撑现代城市运转的重要基础设施,是隐藏在地面之下的庞大工程网络。这些管网如同城市的血脉,负责输送各种必要的资源,如水源、热力、燃气等,同时排除废水和其他废弃物。然而,由于其位于地下,人们往往难以直接感知其存在和运行状态。为了保障这些地下管网的安全…

Go编程实战:高效利用encoding/binary进行数据编解码

Go编程实战&#xff1a;高效利用encoding/binary进行数据编解码 引言encoding/binary 包核心概念ByteOrder 接口Binary 数据类型的处理处理复杂数据结构 基础使用教程数据类型与二进制格式的映射基本读写操作写操作 - binary.Write读操作 - binary.Read 错误处理 高级功能与技巧…

手机备忘录可以设置密码吗 能锁屏加密的备忘录

在繁忙的生活中&#xff0c;手机备忘录成了我随身携带的“小秘书”。那些关于工作的灵感、生活的琐事&#xff0c;甚至深藏心底的小秘密&#xff0c;都被我一一记录在里面。然而&#xff0c;每次当手机离开我的视线&#xff0c;或者需要借给他人使用时&#xff0c;我总会心生担…

Vue+SpringBoot打造校园疫情防控管理系统

目录 一、摘要1.1 项目介绍1.2 项目录屏 二、功能模块2.1 学生2.2 老师2.3 学校管理部门 三、系统展示四、核心代码4.1 新增健康情况上报4.2 查询健康咨询4.3 新增离返校申请4.4 查询防疫物资4.5 查询防控宣传数据 五、免责说明 一、摘要 1.1 项目介绍 基于JAVAVueSpringBoot…

力扣刷题Days12第二题--100相同的树(js)

目录 1,题目 2&#xff0c;代码 2.1深度优先遍历 2.2广度优先遍历 3&#xff0c;学习与总结 1,题目 给你两棵二叉树的根节点 p 和 q &#xff0c;编写一个函数来检验这两棵树是否相同。 如果两个树在结构上相同&#xff0c;并且节点具有相同的值&#xff0c;则认为它们是…

数字孪生10个技术栈:数据处理的六步骤,以获得可靠数据。

一、什么是数据处理 在数字孪生中&#xff0c;数据处理是指对采集到的实时或历史数据进行整理、清洗、分析和转化的过程。数据处理是数字孪生的基础&#xff0c;它将原始数据转化为有意义的信息&#xff0c;用于模型构建、仿真和决策支持。 数据处理是为了提高数据质量、整合数…

ElasticSearch之通过search after和scroll解决深度分页问题

写在前面 通过from&#xff0c;size来进行分页查询时&#xff0c;如下&#xff1a; 当from比较大时会有深度分页问题&#xff0c;问题产生的核心是coordinate node需要从每个分片中获取fromsize条数据&#xff0c;当from比较大&#xff0c;整体需要获取的数据量也会比较大&am…

阿珊解析Vuex:实现状态管理的利器

&#x1f90d; 前端开发工程师、技术日更博主、已过CET6 &#x1f368; 阿珊和她的猫_CSDN博客专家、23年度博客之星前端领域TOP1 &#x1f560; 牛客高级专题作者、打造专栏《前端面试必备》 、《2024面试高频手撕题》 &#x1f35a; 蓝桥云课签约作者、上架课程《Vue.js 和 E…

[c++] c++ 中的顺序(构造,析构,初始化列表,继承)

对象构造的时候&#xff0c;对象成员变量的初始化顺序是什么样的 &#xff1f; 派生类构造的时候&#xff0c;先构造基类还是先构造派生类 &#xff1f; 构造函数中的初始化列表&#xff0c;初始化的顺序是列表的顺序吗 &#xff1f; 析构的时候&#xff0c;析构的顺序是什么…

静态时序分析:典型与非典型时序路径的约束详解(一)

相关阅读 静态时序分析https://blog.csdn.net/weixin_45791458/category_12567571.html?spm1001.2014.3001.5482 时序路径是静态时序分析中的一个重要概念&#xff0c;了解时序路径能帮助设计者更好地编写SDC脚本&#xff0c;本文旨在详细介绍时序路径相关内容。 首先给出时序…

【重制版】WSDM 2024 2023时空时序论文总结

&#x1f31f;【紧跟前沿】“时空探索之旅”与你一起探索时空奥秘&#xff01;&#x1f680; 欢迎大家关注时空探索之旅 WSDM 2024于2024年3月4日-3月8日在墨西哥梅里达&#xff08;Mrida, Mxico&#xff09;正在举行。目前官网已经放出了所有被录用论文的表单&#xff08;链接…

实现消息队列(Kafka、ActiveMQ、RabbitMQ和RocketMQ)高可用

概述 单机没有高可用可言&#xff0c;高可用都对集群来说的 要保证消息队列系统&#xff08;如Kafka、ActiveMQ、RabbitMQ和RocketMQ&#xff09;的高可用性&#xff0c;可以采取以下一些通用的措施&#xff1a; 集群部署&#xff1a;将消息队列系统部署为集群&#xff0c;包…

uniapp和vue项目配置多语言,实现前端切换语言

在uniapp中配置多语言功能&#xff0c;实现前端切换语言&#xff0c;可以按照以下步骤进行&#xff1a; 1. 创建语言包 首先&#xff0c;创建一个名为 lang 的目录&#xff0c;并在该目录下为每种支持的语言创建对应的JSON或JS文件。例如&#xff1a; lang/en.js&#xff08…

【Linux】深入理解cd命令

&#x1f34e;个人博客&#xff1a;个人主页 &#x1f3c6;个人专栏&#xff1a;Linux ⛳️ 功不唐捐&#xff0c;玉汝于成 目录 前言 正文 基本用法&#xff1a; 相对路径和绝对路径&#xff1a; 特殊符号和快捷方式&#xff1a; 符号链接&#xff1a; 自动补全&…