C++入门攻略

简介: C++入门攻略在代码中引用的格式:类型& 引用变量名(对象名) = 引用实体;5.2 引用的特性:#include<stdio.h>

1.命名空间:

1.1 命名空间

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

dd2f40c263ed0081b805f80e6da63341_bbbaedad813b43c3bdc3edd0cee5c3d3.png

比如:这里我想定义一个rand变量,但与库中的函数rand重名,C语言里就直接报错,没有办法。那C++有什么办法吗?有的,就是namespace关键字!


namespace关键字

这里我们就直接来展示下:

4ff070dccd6ef4d69beca0defebf5e75_b9191a841c244d989b7a6a1a079a2beb.png

这里就相当于于直接访问了我们设置的空间里的rand,非常准确,避免了和库里的函数rand命名冲突


  • 具体来解释下:我们要先认识这个符号:: 叫做域作用限定符,在这里C::相当于是明确地方:C空间中的rand。
  • 那么我们提出一个问题:我们知道C语言中局部变量和全局变量,优先访问局部,那C++有办法解决吗?
  • 答案是肯定的:如下例子

3a57f5e1083b665edf1f9a1f296d5747_00822afb352d416e87b4aaa51c5a1964.png

  • 这里我们直接在::域作用限定符前为空的,就可以优先访问全局变量。

上面就简单举了两个例子来说明了一下,接下来我们就进一步学习namespace关键字:

1.命名空间中可以定义变量、函数、类型

namespace C
{
  //变量:
  int a = 10;
  
  //函数:
  int Add(int left, int right)
  {
  return left + right;
  }
  
  //类型:结构体
  struct Node
  {
  struct Node* next;
  int val;
  };
}

2.命名空间可以嵌套

namespace C1
{
  //变量:
  int a = 10;
  
  //函数:
  int Add(int left, int right)
  {
  return left + right;
  }
  //嵌套命名空间:
  namespace C2
  {
    int a=20;
  }
}
  • 嵌套命名空间的访问:比如这里我要访问C2的aC1::C2::a

3.相同命名空间共存

在一个工程中,比如在test.cpp和test.h文件中都有N1命名空间,那么会将两个文件的同名空间整合

1.2 命名空间的使用方式:

1.名称加用域作用限定符的方式访问(同上)

2.使用using引入某个空间中的某个变量

如图,我们用了using引入了C中的b,就可以直接访问量

3.使用using引入展开某个空间:

同样可以实现直接访问变量b。

  • 当然这里需要强调一下,直接全部展开会有风险,如果我们定义的命名空间和库里的重名也会报错的。

2. C++的输入与输出:

了解了上面的知识,确实这样写就不大好了,当然如果是竞赛,全部展开还会影响代码速度。

#include<iostream>
// std是C++标准库的命名空间名,C++将标准库的定义实现都放到这个命名空间中
using namespace std;
int main()
{
cout<<"Hello world!!!"<<endl;
return 0;
}

这里就不如单独展开,或者单独访问

#include<iostream>

using  std::cout;
using  std::endl;
int main()
{
cout<<"Hello world!!!"<<endl;
std::cout<<"Hello world!!!"<<std::endl;
return 0;
}

说明:


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

3.缺省参数

3.1 缺省参数的概念:

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

3.2 缺省参数的分类:

全缺省参数:

void Func(int a = 10, int b = 20, int c = 30)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}

半缺省参数:

void Func(int a, int b = 10, int c = 20)
{
cout<<"a = "<<a<<endl;
cout<<"b = "<<b<<endl;
cout<<"c = "<<c<<endl;
}

注意:


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

解释:我们函数输入参数是按照从左向右的顺序,如果半缺省参数也从左向右的顺序来,那么就很有可能后面的参数没有默认值,导致参数缺少;


2.缺省参数不能在函数声明和定义中同时出现,在声明给缺省。

理由:在预处理阶段—编译阶段我们都只能看到声明文件,不包含定义文件,所以如果是声明没有给缺省,我们传入参数数量若少于声明参数数量则会报错。所以我们就在声明给缺省。


3.缺省值必须是常量或者全局变量


4.C语言不支持(编译器不支持)

4.函数重载

4.1 函数重载的概念:

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

#include<iostream>
using namespace std;
// 1、参数类型不同
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;
}
// 2、参数个数不同
void f()
{
  cout << "f()" << endl;
}
void f(int a)
{
  cout << "f(int a)" << endl;
}
// 3、参数类型顺序不同
void f(int a, char b)
{
  cout << "f(int a,char b)" << endl;
}
void f(char b, int a)
{
  cout << "f(char b, int a)" << endl;
}
int main()
{
  Add(10, 20);
  Add(10.1, 20.2);
  f();
  f(10);
  f(10, 'a');
  f('a', 10);

  return 0;
}

5.引用

5.1 引用的基本概念:

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

比如:李逵,在家称为 铁牛 ,江湖上人称黑旋风。只是别名。

在代码中引用的格式:类型& 引用变量名(对象名) = 引用实体;

5.2 引用的特性:

#include<stdio.h>
int main()
{
  int a = 10;
  int b = 20;
  //int& b;这里会报错,原因引用必须初始化
  int& ra = a;//这里就是定义ra为a的别名
  int& rra = a;//一个变量可以有多个引用
  //int& ra=b;//这里会报错,引用只能引用一个引用实体,引用在C++中是不能更改的;
  printf("%d %d %d\n", a, ra,rra);
  //打印结果为:10  10  10
  printf("%p %p %p\n", &a, &ra,&rra);
  //打印结果为:00B3F70C 00B3F70C 00B3F70C
  ra=b;//赋值操作,a.ra.rra为同一空间,一个改变其他肯定改变,值是统一的,只是称呼不同罢了
  printf("%d %d %d\n", a, ra,rra);
  //打印结果为:20  20  20
}

从上面代码我们可以得出引用的特性:

  1. 引用定义必须初始化,也就是必须有引用实体;
  2. 一个变量可以有多个引用;
  3. 引用一旦引用一个实体,再不能引用其他实体;

5.3 常引用:

#include<stdio.h>
int main()
{
  //引用过程中权限不能扩大,但可以平移和缩小
  const int a = 10;
  //int& ra = a; // 该语句编译时会出错,a为常量--权限扩大(x)
  int c = 20;
  const int& rc = c;//权限缩小
  const int& ra = a;//权限平移
}
  • 结论:引用过程权限只能平移或者缩小,不能扩大
// int& b = 10; // 该语句编译时会出错,b为常量--权限扩大(x)
  const int& b = 10;
  
  double d = 12.34;
  //int& rd = d; // 该语句编译时会出错,类型不同--权限扩大(x)
  const int& rd = d;//为什么不报错呢?为什么加个const就可以了

再看这个例子,const int& rd = d;//为什么不报错呢?为什么加个const就可以了?其实这个对比上面局的b的例子或许能得出答案;


  • 10是一个常量,类型可以看做为const int类型,所以第一句是权限扩大,会报错。所以加const修饰就可以,实现权限平移,不会报错
  • 第二个是会发生强制类型转化,但转换过程中会用到中间临时变量,临时变量具有常性,为一个常量,所以理由同上;
int func1()
{
  int x = 10;
  return x;
}

int& func2()
{
  int x = 10;
  return x;
}

int main()
{
  int ret = func1();//拷贝
  //int& ret = func1();报错,权限扩大(x)
  const int& ret = func1; //和上面一样,返回值的话是需要通过临时变量的,也就同上

  int& ret = func2();//这就没有问题,这里的func2()相当于对x的取别名,这里就相当于再次取别名
  const int& ret = func2();//权限的缩小;
}

5.4 引用使用场景:

  1. 做参数:
//拿交换函数来举个例子:
void Swap(int& left,int& right)
{
  int tem = left ;
  left = right;
  right =tem;
}

Swap(a,b);

在上述代码中,其实我们传入的a,b就不在是a,b的值拷贝了,而是a,b的别名,所以更改left,right就可以实现更改a,b;


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

  1. 做返回值:
//传值返回
#include<stdio.h>
#include<iostream>
using namespace std;

int& count(int x)//返回一个n的别名
{
  int n = x;
  n++;
  return n;
}

int main()
{
  int& ret = count(10);//别名的多层复用
  cout << ret << endl;//运行结果:11

  count(20);
  rand();
  cout << ret << endl;//运行结果:随机值
}

为什么这里会出现错误,而不是和我们上面所说的一样,n一改变其他别名也会改变呢?其实这里依旧是这个原理,但不一样的是这里的n为局部变量,n在调用过后栈区间会清除(并非销毁空间,归还区间访问权,清理该区间的数据)。那问题来了,为什么第一个答案是11是正确的呢,这可能跟编译器有关,编译器没有在清除该区域,只是收回了访问权(比如:指针就无法访问到这片空间,但值或许没变),但在调用rand()函数或者随机一个函数时,会开辟空间,就可能会利用到n那片空间,系统在栈帧操作过程中,就会有赋值,所以当我们引用继续访问时,发现值已经改变;


总结:传参引用都可以使用,但作为返回值需要考虑传回参数是否会出作用域后被清除。

6.内联函数

6.1 概念:

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

如果在上述函数前增加inline关键字将其改成内联函数,在编译期间编译器会用函数体替换函数的调用。查看方式:

  1. 在release模式下,查看编译器生成的汇编代码中是否存在call Add
  2. 在debug模式下,需要对编译器进行设置,否则不会展开(因为debug模式下,编译器默认不会对代码进行优化)

6.2 特性:

  1. inline是一种以空间换时间的做法,如果编译器将函数当成内联函数处理,在编译阶段,会用函数体替换函数调用,缺陷:可能会使目标文件变大,优势:少了调用开销,提高程序运行效率。
  2. inline对于编译器而言只是一个建议,不同编译器关于inline实现机制可能不同,一般建议:将函数规模较小(即函数不是很长,具体没有准确的说法,取决于编译器内部实现)、不是递归、频繁调用的函数采用inline修饰,否则编译器会忽略inline特性。
  3. inline不建议声明和定义分离,分离会导致链接错误。因为inline被展开,就没有函数地址了,链接就会找不到。
相关文章
|
8天前
|
程序员 C++
C++模板元编程入门
【7月更文挑战第9天】C++模板元编程是一项强大而复杂的技术,它允许程序员在编译时进行复杂的计算和操作,从而提高了程序的性能和灵活性。然而,模板元编程的复杂性和抽象性也使其难以掌握和应用。通过本文的介绍,希望能够帮助你初步了解C++模板元编程的基本概念和技术要点,为进一步深入学习和应用打下坚实的基础。在实际开发中,合理运用模板元编程技术,可以极大地提升程序的性能和可维护性。
|
6天前
|
存储 安全 编译器
【C++入门 四】学习C++内联函数 | auto关键字 | 基于范围的for循环(C++11) | 指针空值nullptr(C++11)
【C++入门 四】学习C++内联函数 | auto关键字 | 基于范围的for循环(C++11) | 指针空值nullptr(C++11)
|
6天前
|
存储 自然语言处理 编译器
【C++入门 三】学习C++缺省参数 | 函数重载 | 引用
【C++入门 三】学习C++缺省参数 | 函数重载 | 引用
|
6天前
|
小程序 C++
【C++入门 二 】学习使用C++命名空间及其展开
【C++入门 二 】学习使用C++命名空间及其展开
|
6天前
|
人工智能 分布式计算 Java
【C++入门 一 】学习C++背景、开启C++奇妙之旅
【C++入门 一 】学习C++背景、开启C++奇妙之旅
|
22天前
|
编译器 C语言 C++
【C++】学习笔记——C++入门_2
【C++】学习笔记——C++入门_2
22 6
|
22天前
|
安全 编译器 C语言
【C++】学习笔记——C++入门_3
【C++】学习笔记——C++入门_3
27 4
|
22天前
|
程序员 编译器 C语言
【C++】学习笔记——C++入门_1
【C++】学习笔记——C++入门_1
28 4
|
22天前
|
安全 编译器 程序员
【C++初阶】--- C++入门(上)
【C++初阶】--- C++入门(上)
14 1
|
23天前
|
安全 编译器 C语言
C++练级之路——C++入门
C++练级之路——C++入门
14 1