C++知识篇(1)(下) - 指南

【C++知识篇(1)(上) - CSDN App】https://blog.csdn.net/qscftqwe/article/details/155275574?sharetype=blog&shareId=155275574&sharerefer=APP&sharesource=qscftqwe&sharefrom=link

如果没有看过上篇的可以点击观看

下面废话不多说我们直接进入今天的正题吧！

一.引用

1.1 引用的概念

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

比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"其中铁牛和黑旋风都是他的称号

格式：类型 & 别名 = 引用对象；

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

要点：引用类型必须和引用实体是同种类型的

1.2 引用的特性

引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，则不能在引用其他实体（这也是引用不能完全替代指针）
不产生空间（语法上）

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

1.3 常引用

常引用的出现：首先引用的权限<=引用的对象，因此const对象想，要引用它，那么权限应该<=const因此不加const会报错，权限只能缩小或平移不能放大，常引用不能改变（相对的），但是可能可以通过引用对象改变而改变。

int main()
{
    int a = 100;
    const int & b = a;
    b = 20;//报错因为常引用不能修改
    a = 200;
    //b也应该等于200，虽然常引用不能改变，但是可以通过改变引用对象从而改变常引用
    const int c = 100;
    const int & b = c;
    //那么此时常引用才能真正算是真正不能改变
}

权限变化要点：常数，隐式类型转换和返回值（产生临时变量）都带有常性，要用常引用

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

1.4 使用场景

做参数

void Swap(int& left, int& right)//想通过形参修改实参
{
    int temp = left;
    left = right;
    right = temp;
}
int Add(const int& left, const int& right)//只想节省空间不想通过修改形参改变实参
{
    return left + right;
}

做返回值

int& Count()
{
    static int n = 0;
    n++;
    return n;
}

要点：

做参数：此时在函数体里面对形参改变会影响实参。

做返回值：如果返回对象是局部的话，会导致出了作用域该对象被清空，因此出现引用的对象是随机的，所以当引用对象是局部的话要采用值返回。

1.5 引用作用

①修改返回值②提升效率（减少拷贝）

1.6 引用和指针的区别

引用不需要开空间，指针需要开空间
引用在定义时必须初始化，指针没有要求
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
没有NULL引用，但有NULL指针
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但是没有多级引用
访问实体方式不同，指针需要显式解引用，引用不需要
引用更安全

二.auto关键字（C++11）

随着程序越来越复杂，程序中用到的类型也越来越复杂，经常体现在：

1.类型难于拼写

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

auto关键字我们这里讲的是C++11，在之前的版本auto关键字有别的作用，至于有什么作用其实不太关键，因为如果关键的话也不会在C++11进行修改了！

作用：可以识别右边表达式的类型

格式：auto 变量 = 表达式；

int main()
{
    int a = 10;
    auto b = a;
    auto c = 'a';
    auto d = TestAuto();
}

要点：

auto定义变量必须对其初始化

auto不能作函数参数，数组类型，同一行声明多个变量

void TestAuto()
{
    auto a = 1, b = 2;
    auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}
// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}
void TestAuto()
{
    int a[] = {1,2,3};
    auto b[] = {4，5，6};
}

auto声明指针类型时，auto和auto*无区别，但用auto声明引用必须要加&

int main()
{
    int x = 10;
    auto a = &x;
    auto* b = &x;
    auto& c = x;
    cout << typeid(a).name() << endl;
    cout << typeid(b).name() << endl;
    cout << typeid(c).name() << endl;
    *a = 20;
    *b = 30;
     c = 40;
    return 0;
}

三.基于范围的for循环（C++11）

在C++11以前中如果要遍历一个数组，可以按照以下方式进行：

void TestFor()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
        array[i] *= 2;
    for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
        cout << *p << endl;
}

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

格式：for（类型变量：数组名）

void TestFor()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for(auto& e : array)
         e *= 2;
    for(auto e : array)
         cout << e << " ";
    return 0;
}

我们通常用auto来推到是什么类型

注意：与普通循环类似，可以用continue来结束本次循环，也可以用break来跳出整个循环

3.1 范围for的使用条件

for循环迭代的范围必须是确定的对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。（不过这是后面要讲的内容，先了解一下即可）

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

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


迭代的对象要实现++和==的操作。(关于迭代器这个问题，以后会讲，现在提一下，没办法 讲清楚，现在大家了解一下就可以了)
四.指针空值nullptr(C++11)
    在C++11之前，指针空值都是由NULL充当，但是在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：
void TestPtr()
{
    int* p1 = NULL;
    int* p2 = 0;
}
NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：
#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif
        可以看到，NULL可能被定义为字面常量0，或者被定义为无类型指针(void*)的常量。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如

void f(int)
{
	cout<<"f(int)"<

程序本意是想通过f(NULL)调用指针版本的f(int*)函数，但是由于NULL被定义成0，因此与程序的 初衷相悖。 在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但是编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强转(void *)0。
   因此在C++11中才急需一个只表示void*的关键字，因此nullptr就出现了
 注意：
1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的。
        2. 在C++11中，sizeof(nullptr) 与 sizeof((void*)0)所占的字节数相同。 
        3. 为了提高代码的健壮性，在后续表示指针空值时建议最好使用nullptr。
到这里关于C++知识篇（1）的内容就结束了，不知道大家收获到了多少呢，不过我相信大家肯定都能明白的！

posted @ 2025-12-24 16:50 clnchanpin 阅读(57) 评论(0) 收藏举报

刷新页面返回顶部