C语言向C++过渡的基础知识（三）

最新推荐文章于 2024-04-16 00:18:01 发布
最新推荐文章于 2024-04-16 00:18:01 发布
阅读量1.1k 收藏 19
点赞数 31
分类专栏： C++基础知识 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73281594/article/details/136799927
版权

目录

auto类型变量（C++11标准支持）

auto关键字介绍

auto关键字的使用

auto关键字基本使用

auto关键字配合指针和引用

auto关键字不可以推导的场景

基于范围的for循环（C++11标准支持）

基于范围的for循环基础使用

基于范围的for循环使用条件

空指针值（C++11标准支持）

声明：本篇时C语言向C++过渡的基础知识的最后一篇

auto类型变量（C++11标准支持）

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;
}

可以用typedef来处理上面的问题，但是typedef也有别的问题

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

考虑下面的问题

typedef char* pstring;
int main()
{
    const pstring p1;    // 编译失败，展开后为char* const p1，作为const修饰的变量为常量，只有一次赋值的机会，故需要初始化
    const pstring* p2;   // 编译通过
    return 0;
}

auto关键字的使用

auto关键字基本使用

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量

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

使用auto关键字创建变量的语法如下：

auto 变量名;

auto创建的变量有自动推导类型的特点，例如下面的代码中

//auto关键字
#include <iostream>
using namespace std;

int main()
{
    int a = 0;
    auto b = a;//b自动推导为int类型
    double c = 0.0;
    auto d = c;//c自动推导为double类型

    cout << "a变量的类型为：" << typeid(a).name() << endl;
    cout << "b变量的类型为：" << typeid(b).name() << endl;
    cout << "c变量的类型为：" << typeid(c).name() << endl;
    cout << "d变量的类型为：" << typeid(d).name() << endl;

    return 0;
}
输出结果：
a变量的类型为：int
b变量的类型为：int
c变量的类型为：double
d变量的类型为：double

在上面的代码中，创建了两个普通对象a和c，使用auto关键字创建了两个对象b和d，分别自动匹配了a和c的类型为int和double，使用typeid.name()查看变量类型

需要注意的是，使用auto创建的变量一定要初始化，否则编译器无法推导该变量的类型从而报错

//auto关键字
#include <iostream>
using namespace std;

int main()
{
    auto e;// 报错

    return 0;
}
报错信息：
“e”: 类型包含“auto”的符号必须具有初始值设定项

所以，auto并非是一种“类型”的声明，而是一个类型声明时的“占位符”，编译器在编译期会将auto替换为变量实际的类型

使用auto关键字可以同时创建多个变量，但是必须保证一个auto关键字创建的多个变量匹配一种类型，不可以auto匹配多个类型

#include <iostream>
using namespace std;

int main()
{
    auto a = 1, b = 2, c = 3, d = 4;//所有变量匹配为int类型
    auto f = 2.0, g = 2;//不可以同时匹配多个类型

    return 0;
}
报错信息：
在声明符列表中，“auto”必须始终推导为同一类型

auto关键字配合指针和引用

auto关键字创建的变量也可以自动推导为指针和引用类型，也可以直接将auto关键字创建的变量指定为指针和引用类型，用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

如下

//auto关键字配合指针和引用
#include <iostream>
using namespace std;

int main()
{
    int a = 0;
    int* p = &a;
    auto p1 = p;//自动推导为int*类型
    auto* p2 = p;//指定为int*类型
    //auto* p3 = a;//不可以推导
    auto r1 = a;//自动推导为int类型
    auto& r2 = a;//指定为引用类型

    return 0;
}

编译器指示如下：

auto关键字不可以推导的场景

  • auto关键字创建的变量不可以作为函数形参
void test(auto a)
{

}

#include <iostream>
using namespace std;

int main()
{
    test(1);
    return 0;
}
报错信息：
参数不能为包含“auto”的类型
  • auto不能直接用于声明数组
#include <iostream>
using namespace std;

int main()
{
    int arr[] = { 1,2,3,4,5 };
    auto arr1[] = { 1,2,3,4,5 };//不可以直接用来创建数组

    return 0;
}
报错信息：
“auto”类型不能出现在顶级数组类型中

但是可以获取到数组的地址

#include <iostream>
using namespace std;

int main()
{
    int arr[] = { 1,2,3,4,5 };
    auto arr1 = arr;//可以将已经创建的数组给auto创建的变量，自动匹配为int*
    cout << "arr1：" << typeid(arr1).name() << endl;
    for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
    {
        cout << "arr1[i]：" << arr1[i] << endl;
    }

    return 0;
}
输出结果：
arr1：int * __ptr64
arr1[i]：1
arr1[i]：2
arr1[i]：3
arr1[i]：4
arr1[i]：5

基于范围的for循环（C++11标准支持）

基于范围的for循环基础使用

在C++98中需要按照常规方式进行数组的遍历，例如

#include <iostream>
using namespace std;

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

    return 0;
}
输出结果：
1 2 3 4 5

但是在C++11中可以按照下面的方式进行遍历

#include <iostream>
using namespace std;

int main()
{
    int arr[] = { 1,2,3,4,5 };

    for (int num : arr)
    {
        cout << num << " ";
    }

    return 0;
}

在上面的for循环中，创建了一个num变量，将数组中的元素给num变量，再打印num变量

鉴于上面的过程说明，如果想用上面的方式修改数组中的元素则不会成功

#include <iostream>
using namespace std;

int main()
{
    int arr[] = { 1,2,3,4,5 };

    for (int num : arr)
    {
        num *= 2;
        cout << num << " ";
    }
    cout << endl;
    for (int num : arr)
    {
        cout << num << " ";
    }

    return 0;
}
输出结果：
2 4 6 8 10
1 2 3 4 5

此时可以配合引用进行原数组内容的修改

#include <iostream>
using namespace std;

int main()
{
    int arr[] = { 1,2,3,4,5 };

    for (int& num : arr)
    {
        num *= 2;
        cout << num << " ";
    }
    cout << endl;
    for (int num : arr)
    {
        cout << num << " ";
    }

    return 0;
}
输出结果：
2 4 6 8 10
2 4 6 8 10

📌

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

基于范围的for循环也可以使用auto创建循环变量

#include <iostream>
using namespace std;

int main()
{
    int arr[] = { 1,2,3,4,5 };

    for (auto num : arr)
    {
        cout << num << " ";
    }
    cout << endl;
    for (auto& num : arr)
    {
        num *= 2;
        cout << num << " ";
    }

    return 0;
}
输出结果：
1 2 3 4 5
2 4 6 8 10

基于范围的for循环使用条件

for循环迭代的范围必须是确定的

#include <iostream>
using namespace std;
void test(int* arr)
{
    for (auto num : arr)
    {
        cout << num << " ";//不可以遍历，因为无法确定范围，数组在传参时只会传递第一个元素的地址
    }
}

int main()
{
    int arr[] = { 1,2,3,4,5 };
    test(arr);
    return 0;
}

空指针值（C++11标准支持）

在良好的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*)的常量，不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦，比如在函数重载中可能会使编译器匹配参数为整型的函数，而不是参数为指针类型的函数：

#include <iostream>
using namespace std;

void test(int a)
{
    cout << "匹配int类型形参" << endl;
}

void test(int* a)
{
    cout << "匹配int*类型形参" << endl;
}

int main()
{
    test(0);
    test(NULL);
    return 0;
}
输出结果：
匹配int类型形参
匹配int类型形参

此时为了使形参匹配到指针类型，必须将NULL或者0强制转换为(void*)类型

void test(int a)
{
    cout << "匹配int类型形参" << endl;
}

void test(void* a)
{
    cout << "匹配int*类型形参" << endl;
}

int main()
{
    test(0);
    test((void*)NULL);
    return 0;
}

为了解决上面的问题，C++11标准中提出了nullptr用于指定指针空值

#include <iostream>
using namespace std;

void test(int a)
{
    cout << "匹配int类型形参" << endl;
}

void test(int* a)
{
    cout << "匹配int*类型形参" << endl;
}

int main()
{
    test(0);
    //test((void*)NULL);
    test(nullptr);
    return 0;
}
输出结果：
匹配int类型形参
匹配int*类型形参

在使用nullptr时注意下面的三点：

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

int main()
{
    cout << "sizeof(NULL)：" << sizeof(NULL) << endl;
    cout << "sizeof(nullptr)：" << sizeof(nullptr) << endl;
    cout << "sizeof((void*)0)：" << sizeof((void*)0) << endl;
    return 0;
}
输出结果：
sizeof(NULL)：4
sizeof(nullptr)：8
sizeof((void*)0)：8
怡晗★
关注
专栏目录
Visual C++ 2010新功能之auto关键字
一个人的旅行
12-11 1882
  C语言里面其实就已经有auto关键字了，只不过很少用到，当我们在C或者以前的C++中，auto关键字基本上可以被无视：比如这个局部变量: int a = 100; auto int a = 100;并没有什么区别，但是在VC2010中， auto已经有了新的含义，它可以对类型进行推断使得我们在使用的时候可以这样auto a = 100;那么a就是int类型，初始值为100. 下面是一个
C++ 深入理解 auto 关键字
稚枭天卓
07-23 7678
auto类型变量——根据初始值推断真实的数据类型。本文将从，【为什么auto】【auto代码使用示例】【auto概念详解】【auto注意事项】【register/auto的比较分析】【auto类型(普通)static局部变量有三点不同】六个维度深入讲解auto关键字
c++ map映射表
03-05 1432
map&lt;int,int&gt; myMap;    创建一个map后是有初始值的，初始值为0；if(myMap.find(42)!=myMap.end())   //即使myMap里没有42，但这样访问了一次以后，会自动插入一个键42到myMap，值为0要想删掉该键值，就要使用 myMap.erase（42）...
【C++】auto类型说明符
WINGREZ‘S BLOG
02-28 1152
本文参考自《C++ Prime 第四版 中文版》 auto类型说明符 1、C++11标准引入了auto类型说明符，用它能让编译器主动去分析表达式所属的类型。 2、auto定义变量必须有初始值，编译器通过初始值来推算变量的类型。 3、可以在一条语句中用auto声明多个变量，但要求该语句中所有变量的初始值的基本数据类型都必须一样。(注意*和&amp;并非基本数据类型的一部分) 例如： auto ...
从C语言转C++简明教程
10-13
本文档“从C语言转C++简明教程”将引导你从熟悉C语言的基础出发，逐步过渡到掌握C++的核心概念和技术。以下是这个教程可能涵盖的一些关键知识点： 1. **C++概述**：C++是由Bjarne Stroustrup在C语言的基础上发展...
C语言向C++过渡的学习路径与实践
资源摘要信息:"本文档详细记录了学习者在完成C语言学习后，过渡到...以上知识点详细地涵盖了从C语言到C++的过渡学习过程，旨在帮助学习者理解和掌握C++的基础知识和高级特性，并能够有效地应用这些知识于实际开发中。
记录学习完C语言后，学习C++的过程，实现从C语言到C++的过渡.zip
06-25
从C语言转向C++的学习过程是一个提升编程能力的关键步骤，下面将详细介绍这个过渡过程中的核心知识点。 首先，理解C++的基础语法是必要的。虽然C++与C语言有很多相似之处，但C++引入了一些新的关键字和特性，如`...
C语言与C++学习-入门与进阶
02-21
C语言作为基础，以其高效、灵活和简洁而著名，而C++是在C语言基础上扩展的，引入了面向对象编程（OOP）的概念，为开发者提供了更强大的功能和更高的抽象层次。 C语言的核心知识点包括： 1. **基本语法**：C语言的...
C++学习之旅：如何实现从C语言到C++的过渡
资源摘要信息: "本资源主要介绍了C语言和C++之间的差异以及如何从C语言平滑过渡到C++的学习过程。资源中包含了使用QT这个集成开发环境（IDE）作为学习C++的工具。本资源的目标受众为已经掌握C语言并希望进一步学习...
【C++】——入门（关键字，命名空间，输入输出，缺省参数，函数重载，内联函数，auto关键字与基于范围的for循环)
最新发布
m0_74092462的博客
04-16 1224
在写c++的程序的时候，经常会写道using namespace std,这段代码，其实这个的意思就是展开std这个命名空间，使得我们可以用里面的函数和操作符 之所以要有这个命名空间，是因为在c语言里面定义了与库函数同名的变量就会报错，只能修改名字，所以这里使用了这个命名空间去封装，变成一个域，这个域，不使用特殊的操作符是访问不到的
C语言中typedef用法
数据库天地
11-15 157
原文请参考：C语言中typedef用法 1.基本解释 　　typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型（int,char等）和自定义的数据类型（struct等）。 　　在编程中使用typedef目的一般有两个： 给类型名取一个易记且意义明确的新名字； 简化一些比较复杂的类型声明。 　　至于typede...
【C++学习】基础语法（二）
joes_ju的博客
02-06 644
本文适合入门语法学习，包含内联函数、关键字auo、关键字const、关键字nullptr及基于范围的for循环
C++入门（二）
Rainai的博客
04-09 669
我们总结一下：引用：1、做参数（a、输出型参数 b、对象比较大，减少拷贝，提高效率（指针也可以做到这些，但是引用更方便）减少拷贝的原因在于，引用和原本的变量用的是同一空间，不会开辟新的空间，所以节省了内存的消耗2、做返回值（a、修改返回对象 b、减少拷贝提高效率）在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它，大家可思考下为什么？
针对C的不足而改进的C++基础语法
huangdou510的博客
09-24 586
namespace 标识符 {}例如：a. 变量//注意此处fmax仍然是全局变量//全局变量和局部变量根本区别在于存储于内存中不同的区{}int main(){return 0;}第一个输出的值其实是库函数fmax的地址，函数名就是函数的地址；第二个值因为指定了是命名空间cal里面的fmax，所以输出10。b. 函数{{}}int main(){return 0;}c. 类型{{int val;};
C/C++编程：auto
OceanStar的博客
06-11 1253
从其初始化表达式中推导声明的变量的类型 auto与初始化表达式 auto初始化表达式可以采用多种形式 通用初始化语法，如 auto a { 42 }; 。 赋值语法，如 auto b = 0; 通用赋值语法，它结合了前两种形式，例如auto c = { 3.14156 }; 。 直接初始化或构造函数样式语法，如 auto d( 1.41421f ); #include <initializer_list> using namespace std; int main() { a.
浅析C语言auto关键字和C++ 中的auto关键字
热门推荐
Keep Fighting All The Time
06-22 4万+
最近在读《C++ Prime》，不禁想感叹一句：C++真是一种美丽的语言！！！！！！！ C++提供了相比于 C语言更加丰富的库函数，功也更加强大。举个例子吧。
关于C/C++中的auto关键字
feifei__wang的博客
07-14 614
      最近在读《C++ Prime》，不禁想感叹一句：C++真是一种美丽的语言！！！！！！！      C++提供了相比于 C语言更加丰富的库函数，功也更加强大。举个例子吧。      题目：编写一段程序，读入一段包含标点符号的字符串，将标点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

怡晗★

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值