C++练级之路——C++入门

风掣长空

已于 2024-06-21 14:17:10 修改

阅读量867

点赞数 31

分类专栏： C++ 文章标签： c++ 算法开发语言

于 2024-03-31 21:13:19 首次发布

本文链接：https://blog.csdn.net/soi55gshig/article/details/137126495

版权

C++ 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

本文介绍了C++中的命名空间解决命名冲突，输入输出使用cin/cout，缺省参数、函数重载、引用、内联函数、auto关键字、范围for循环和nullptr的使用。

摘要由CSDN通过智能技术生成

9. 指针空值nullptr(C++11)

1、命名空间

在C/C++中会出现大量的变量，函数，起名字是一个很大的问题，为了防止命名重复，就出现了命名空间的概念，使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突和名字污染

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

命名空间内可以定义变量，函数，也可以嵌套定义，使用命名空间有三种方式：

1.直接展开命名空间

using namespace ljp

ljp是命名空间的名字，自己可以随便起，要是有相同名字的命名空间，会合并成一个空间

2.使用using将命名空间中某个成员引入

using ljp::a

例如我引入的是一个int 类型的变量a，::是作用域限定符，

3.加命名空间和作用域限定符

ljp::a

这样就可以直接使用a变量了

2、C++的输入&输出

C++定义了新的输入和输出，输入是cin,输出是cout，但是使用时要展开C++官方的命名空间

using namespace std ，例如:

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	cin >> a;
	cout << a << endl;
	cout << "hello world" << endl;
	return 0;
}

使用cin和cout输入输出非常方便，不需要控制格式了，cin和cout可以自动识别类型，关于更加复杂的知识我们后面了解，这里简单使用一下输入输出。

std命名空间的使用惯例：

1.在日常练习中建议直接展开using namespace std，这样比较方便。

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

3、缺省参数

缺省参数的定义

缺省参数是声明或定义函数时为函数的参数指定一个缺省值，在调用这个函数时，如果实参没有指定的函数值，就采用该缺省参数。

第一个fun()函数，没有指定实参的值，则默认使用形参的缺省值，第二个fun()函数，实参是20，那么就用实参的值。

缺省参数的分类

全缺省参数

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.缺省参数不能在函数定义和声明中同时出现，最好是在函数声明中定义缺省参数，因为当我们定义对象时传的有参数，那么缺省参数就不算了，那么当我们定义对象时不传参数，这时候就会调用默认构造函数，因为我们写的有参构造函数，编译器不在生成默认构造函数，然而我们在构造函数的声明2中没有缺省值，编译器就会报错，没有合适的构造函数调用；

  //a.h
  void Func(int a = 10);
  
  // a.cpp
  void Func(int a = 20)
 {}
  
  // 注意：如果声明与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该
用那个缺省值。

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

4.C语言不支持。

4、函数重载

重载的概念

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

int Add(int a, int b)
{
	return a + b;
}
int Add(double a, double b)
{
	return a + b;
}
int Add(double a, int b)
{
	return a + b;
}
int Add(int a, double b)
{
	return a + b;
}
int Add(double a, double b,int c)
{
	return a + b+c;
}
int main()
{
	cout << Add(10, 20) << endl;
	cout << Add(10.5, 20.5) << endl;
	cout << Add(10.5, 20) << endl;
	cout << Add(10, 20.5) << endl;
	cout << Add(10.5, 20.5,30) << endl;

	return 0;
}

这些都是同名函数，但都是函数重载；

C++支持函数重载的原理——名字修饰

为什么C++支持函数重载，而C语言不支持函数重载呢？

在C/C++中，一个程序的运行需要经过以下几个阶段：预处理，编译，汇编，链接

1.实际上项目通常是由多个头文件和源文件组成的，当a.cpp中调用b.cpp中的add函数时，编译后连接前，a.o的目标文件中没有add函数的地址，因为add是在b.cpp中定义的，所以add的地址在b.cpp中，

2. 链接器看到a.o调用add,但是没有add的地址，就会到b.o的符号表中去找add的地址，然后链接到一起，

3.但是链接器会使用哪个名字去找呢？这里每个编译器都会有自己的函数名修饰规则。具体的up主就噶了（我也不会了，更加深入了，以后慢慢了解）

4.通过这里就理解了C语言没办法支持重载，因为同名函数没办法区分。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

5.如果两个函数函数名和参数是一样的，返回值不同是不构成重载的，因为调用时编译器没办法区分了。

5、引用

引用的概念

引用不是新定义一个变量，而是给已存在变量取一个别名，编译器不会为引用变量开辟内存空间，

它和它引用的变量共用同一块内存空间。

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

voidTestRef()
{
    inta=10;
    int&ra=a;//<====定义引用类型
    printf("%p\n", &a);
    printf("%p\n", &ra);
}

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

引用特性

1.引用在定义时必须初始化；

2.一个变量可以有多个引用；

3.引用一旦引用一个实体，不能再引用其他实体。

voidTestRef()
{
   inta=10;
   // int& ra;   // 该条语句编译时会出错
   int&ra=a;
   int&rra=a;
   printf("%p  %p  %p\n", &a, &ra, &rra);  
}

常引用

void TestConstRef()
{
    const int a = 10;
    //int& ra = a;   // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，10为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;
}

1.权限可以平移/缩小，但是不能放大，

2.类型转换会产生临时变量，临时变量具有常性，所以上面代码的最后一行要加上const，否则会报错。

引用的使用场景

略

引用和指针的区别

语法概念上引用就是一个别名，没有独立空间，和实体共用一块空间，但在地层逻辑上是有空间的，

引用和指针的不同点：

1.引用在概念上是定义一个变量的别名，指针是变量的地址；

2.引用在定义时必须初始化，指针没有要求；

3.引用在初始化引用一个实体后，不在引用其他实体，而指针可以指向任何实体；

4.没有NULL引用。但是有NULL指针；

5.在sizeof含义下，引用的大小是引用类型的大小，而地址的指针大小始终是地址空间所占字节大小的个数（64位平台下是8个字节，32位平台下是4个字节）；

6.引用自加则引用的实体增加1，指针自加，即指针向后偏移一个类型的大小，

7.有多级指针，没有多级引用；

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理；

9. 引用比指针使用起来相对更安全。

6、内联函数

以inline修饰的函数是内联函数，编译器会在调用内联函数的地方展开，没有函数栈帧的开辟，提升程序运行的效率， Add就是内联函数；

特性;

1.inline是一种空间换时间的做法，如果编译器将内联函数当一个函数体处理，减少了函数的调用，提高程序效率，但会使目标文件变大；

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建

议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不

是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。下图为

《C++prime》第五版关于inline的建议：

3.Inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开就没有函数地址了，链接就会找不到。

// F.h
#include <iostream>
using namespace std;
inline void f(int i);

// F.cpp
#include "F.h"
void f(int i)
{
 cout << i << endl;
}

// main.cpp
#include "F.h"
int main()
{
 f(10);
 return 0;
}

// 链接错误：main.obj : error LNK2019: 无法解析的外部符号 "void __cdecl 
f(int)" (?f@@YAXH@Z)，该符号在函数 _main 中被引用

7、auto关键字（C++11）

auto可以自动识别变量的类型，auto声明的变量由编译器编译得知，方便了使用者，使用auto变量时一定要初始化，在编译阶段编译器会根据初始化类型来推导auto的实际类型。因此auto并不是一种“类型”的声明，而是一个类型声明的“占位符”，编译时auto会被替换成变量实际的类型。

假设我们定义一个函数指针

void func(int a,int b)

int main()

{

void(*pf1)(int,int)=func;

auto pf2=func;

cout<<typeid(pf1).name()<<endl;

cout<<typeid(pf2).name()<<endl;

}

这段代码中，pf1和pf2是等价的，都是函数指针，我们可以用typeid来查看pf1和pf2的类型

他们类型是相同的。

typedef的用法：

typedef char* pstring;
int main()
{
 const pstring p1;    // 编译成功还是失败？
 const pstring* p2;   // 编译成功还是失败？
 return 0;
}

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

1.用auto声明指针类型时用auto和auto*没有任何区别，但是声明引用类型时必须加&；

2.在同一行定义多个变量时，变量类型要一致，否则会报错；

3.auto不能直接作为函数的参数，也不能直接用来声明数组；

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

lambda表达式等进行配合使用。

8、基于范围的for循环（C++11）

for循环后面的括号有冒号“：”分为两部分，第一部分是范围内用于迭代的变量，第二部分用于被迭代的范围。

范围for的使用条件：

1.for循环迭代的范围必须是确定的；对数组而言，就是数组的第一个元素和最后一个元素，对于类而言，应该提供 begin和end的方法，begin和end就是for循环迭代的范围。

以后会慢慢了解，这里简单了解一下。

9. 指针空值nullptr(C++11)

NULL其实是一个宏，在传统的C头文件中(stdio.h)，我们可以看到以下代码：

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

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

注意：

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的；

2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同；

3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。

风掣长空

关注

31
点赞
踩
31

收藏

觉得还不错? 一键收藏
1
评论
C++练级之路——C++入门

缺省参数是声明或定义函数时为函数的参数指定一个缺省值，在调用这个函数时，如果实参没有指定的函数值，就采用该缺省参数。第一个fun()函数，没有指定实参的值，则默认使用形参的缺省值，第二个fun()函数，实参是20，那么就用实参的值。
复制链接

扫一扫

专栏目录