【C++11新特性】

最新推荐文章于 2024-11-06 23:10:00 发布
最新推荐文章于 2024-11-06 23:10:00 发布
阅读量1.1k 收藏 20
点赞数 39
分类专栏： C++学习记录 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Pumpkin_O/article/details/140679472
版权

一、特性总览表

中文翻译英文名称
_cplusplus宏_cplusplus macro
对齐支持alignment support
通用属性general attribute
原子操作atomic operation
auto类型推导（初始化类型推导）auto(type deduction from initialize)
C99特性C99

强类型枚举

enum class(scoped and strongly typed enums)
复制及再抛出异常copy and rethrow exception
常量表达式constexpr
decltypedecltype
函数的默认模板参数default template parameters for function
显示默认和删除的函数（默认的控制）defaulted and deleted functions (control of defaults)
委托构造函数delegating constructors
并行动态初始化和析构Dynamic initialization and destruction witn concurrency
显示转换操作符explicit conversion operators
扩展的friend语法extended friend syntax
扩展的整型extended integer types
外部模板extern templates
一般化的SFINAE规则generalized SFINAE rules

统一的初始化语法和语义

uniform initialization syntax and semantics
非受限联合体unrestricted union
用户定义的字面量user-defined literals
变长模板variadic templates
类成员初始化in-class member initializers
继承构造函数inherited constructors
初始化列表initializer lists
Lambda函数lambda
局部类型作模板参数local classes as template arguments
long long 整型long long integers
内存模型memory model
移动语义（参见右值引用）move semantics(see rvalue references)
内联名字空间Inline namespace
防止类型收窄preventing narrowing
指针空值nullptr
PODPOD(plain old data)
基于范围的for语句range-based for statement
原生字符串字面量raw string literals
右值引用rvalue references
静态断言static assertions

追踪返回类型语法

trailing return types syntax
模板别名template aias
线程本地的存储thread-local storage
UnicodeUnicode

 

二、部分特性的介绍

1、long long 整型

 long long 整型有两种：long long和unsigned long long。在C++11中，标准要求以long long整型可以在不同平台上有不同的长度，但至少有64位。我们在写常数字面量时，可以使用LL后缀（或是ll）表示一个long long 类型的字面量，而ULL（或是ull、Ull、uLL）则表示一个unsigned long long 类型的字面量。如：

long long int lli = -9000000000000000000LL;
unsigned long long ulli = -9000000000000000000ULL;

在C++11中，有很多与long long等价的类型，比如：long long int 、signed long long 、signed long long int；而unsigned long long 和unsigned long long int则是等价的。

查看<climits>或<limits.h>中的宏来了解long long 整型的最值，共有三个：LLONG_MIN、LLONG_MAX、ULLONG_MAX，如下：

#include<limits>
#include<iostream>
#include<stdio.h>
using namespace std;


int main() {
    long long ll_min = LLONG_MIN;
    long long ll_max = LLONG_MAX;
    unsigned long long ull_max = ULLONG_MAX;
    cout << "long long最小值为：" << ll_min << endl;
    cout << "long long最大值为：" << ll_max << endl;
    cout << "unsigned long long最大值为：" << ull_max << endl;

    return 0;
}

输出结果为：

 

2、右值引用：移动语义和完美转发

 2.1、指针成员与拷贝构造

编写C++程序时，如果在类里有指针成员的话，要特别小心拷贝构造函数的编写，稍不注意，就会造成内存泄漏。若是进行了浅拷贝，就可能会导致内存泄漏，比如：

#inlude<iostream>
using namespace std;

class A{
public:
    A () : d(new int(0))
    {}
    ~A(){
        delete d;
    }
    
    int *d;
};

int main(){
    A a;
    A b(a);
    
    cout<<*a.d<<endl;//0
    cout<<*b.d<<endl;//0
}//异常析构

说明：

定义了一个含有指针变量d的类A；

该成员d在构造时会接受一个new操作分配堆内存返回的指针，而在析构时会被delete操作释放分配的堆内存；

在main函数中，声明了类的对象a，又用a初始化了对象b，此处会调用类A的拷贝构造函数。此处调用的是由编译器隐式生成的拷贝构造函数，作用是类似于memcopy的按位拷贝；

此时就产生了一个问题：a.b和b.d指向了同一块堆内存；

在main函数作用域结束时，会调用析构函数，对象a和对象b的析构函数会被依次调用；

当其中一个析构完成时（如当对象b先被析构，b.d先被delete），指向的堆内存就已经被释放了，而此时a.b指针就不再指向一个有效的内存，无资源可释放，变成了一个悬挂指针。这就会导致内存泄漏。

#inlude<iostream>
using namespace std;

class A{
public:
    A () : d(new int(0))
    {}
    A (A &h) : d(new int(*h.d))
    {}
    ~A(){
        delete d;
    }
    
    int *d;
};

int main(){
    A a;
    A b(a);
    
    cout<<*a.d<<endl;//0
    cout<<*b.d<<endl;//0
}//正常析构

说明：

给类A显示地添加了一个拷贝构造函数，从堆中分配新内存，将分配来的内存的指针给d，又使用*(h.d) 对*d进行初始化，这样a.d和b.d就指向了两块不同的内存，避免了析构时出现悬挂指针。

浅拷贝：

只是简单地把原始对象的内存内容按位复制到新的对象中，包括指针的复制，而不会创建新的内存空间，这就意味着原始对象和新创建的对象会共享同一块内存，对一个对象的修改可能会影响到另一个对象。但不意味着不能使用浅拷贝，在不涉及到动态内存分配时，可使用浅拷贝。

深拷贝：

在创建新对象后，会把原始对象的所有数据成员复制到新对象中，包括动态内存分配。这就意味着在进行深拷贝之后，原始对象和新对象是完全独立的，对一个对象的修改不会影响到另一个对象。通常在涉及到动态内存分配时使用深拷贝，如对象中包含指针或动态数组等。

 

2.2、移动语义

 拷贝构造函数中为指针成员分配新的内存再进行内容拷贝的做法在C++编程中几乎是不可避免的，不过在一些时候，我们确实不需要这样的拷贝构造语义。如果一个对象中有堆区资源，需要编写拷贝构造函数和赋值函数，实现深拷贝，深拷贝把对象中的堆区资源复制了一份，如果源对象是临时对象，拷贝完就没什么作用的话，就会被析构，那这样会造成无意义的资源申请和释放操作。如果能够直接使用源对象拥有的资源，节省资源申请和释放的时间，又要避免浅拷贝，就需要用到移动语义。

#include <iostream>
#include <vector>

class LargeObject {
public:
    LargeObject() {
        // 构造大型对象
        std::cout << "Constructing LargeObject" << std::endl;
    }

    LargeObject(const LargeObject& other) {
        // 拷贝构造函数
        std::cout << "Copying LargeObject" << std::endl;
    }

    LargeObject(LargeObject&& other) noexcept {
        // 移动构造函数
        std::cout << "Moving LargeObject" << std::endl;
    }

    ~LargeObject() {
        // 析构函数
        std::cout << "Destructing LargeObject" << std::endl;
    }
};

int main() {
    std::vector<LargeObject> vec;

    // 添加临时对象
    vec.push_back(LargeObject());

    return 0;
}

2.3、左值、右值与右值引用

在移动语义的构造时，有非常重要的一点就是，其参数是一个右值（或右值引用），这就得对左右值和左右值引用进行学习。

2.3.1、定义 

左值：locator value，简写为lvalue，可以为存储在内存中、有明确存储地址（可寻址）的数据；

 例如：

//a、p、*p、b都为左值
int a = 3;
int *p = &a;
*p;
const int b = 2;

右值：read value，简写为rvalue，指的是那些可以提供数据值的数据。右值不能出现在赋值符号左边且不能取址。

例如：

double x = 1.3 , y = 3.8;
10;//字面常量
x + y;//表达式返回值
fmin(x,y);//传值返回函数的返回值

 区分左值和右值的关键点是：能否取址。

2.3.2、左值引用

左值引用就是对左值的引用，给左值取别名。

int & ra = a;
int *& rp = p;
int & r = *p;
const int & rb = b;

总结： 

  1.  左值引用只能引用左值，不能引用右值；
  2. 但const左值引用既可以引用左值，也可以引用右值。
// 1.左值引用只能引用左值
int t = 8;
int& rt1 = t;

//int& rt2 = 8;  // 编译报错，因为8是右值，不能直接引用右值


// 2.但是const左值引用既可以引用左值
const int& rt3 = t;

const int& rt4 = 8;  // 也可以引用右值
const double& r1 = x + y;
const double& r2 = fmin(x, y);
2.3.3、右值引用

 右值引用是C++11新增的特性。

右值引用就是对右值的引用，给右值取别名。

int&& rr1 = 10;
double&& rr2 = x + y;
double&& rr3 = fmin(x,y);

注意：

  • 右值引用引用右值，会使右值被存储到特定的位置，也就是说，右值引用变量其实是左值，可以对它取址和复制（const右值引用变量可以取址，但不能赋值），当然，取址是指取变量空间的地址，因为右值是不能取址的。 
  • 比如： 
    double&& rr2 = x + y;
&rr2;
rr2 = 6.3;

    右值引用rr2引用右值x+y后，该表达式的返回值会被存储到特定的位置，对rr2取址，也就是取返回值存储位置的地址，也可以修改rr2的值；

  • 再比如：

    const double && rr3 = x + y;
&rr4;

    可以对rr4取址，但是不能修改rr4的值。

 总结：

  1. 右值引用只能引用右值，不能直接引用左值；
  2. 右值引用可以引用被move的左值。（move的作用为将一个左值强制转化为右值，以实现移动语义。）
// 1.右值引用只能引用右值
int&& rr1 = 10;
double&& rr2 = x + y;
const double&& rr3 = x + y;

int t = 10;
//int&& rrt = t;  // 编译报错，不能直接引用左值


// 2.但是右值引用可以引用被move的左值
int&& rrt = std::move(t);
int*&& rr4 = std::move(p);
int&& rr5 = std::move(*p);
const int&& rr6 = std::move(b);

2.3、完美转发

2.3.1、引用折叠

引用折叠的规则如下：

  1. 左值引用与左值引用的折叠：当左值引用与左值引用结合时，结果仍为左值引用。具体来说，以下几种情况都会折叠为左值引用： 
    T& &折叠为T&
T& &&折叠为T&
T& const &折叠为T& const(保留const，表示引用本身不可变，但所引用的对象可变)
  2.  右值引用与右值引用的折叠：当右值引用与右值引用结合时，结果是右值引用： 
    T&& &&折叠为T&&

模板类型T实际类型R最终推导类型
T&RR&
T&R&R&
T&R&&R&
T&&RR&&
T&&R&R&
T&&R&&R&&

从上表中可以发现：只要有左值引用参与，最终推导类型都为左值引用。

万能引用：格式与右值引用类似（都是两个&），无论传入什么值还是引用都能接收，并且通过引用折叠的方式给其确定一个确切的类型。

2.3.2、完美转发

 C++11中完美转发是在万能引用的基础上进行优化，对于一个对象，传入什么类型，就按照什么类型进行转发。

示例分析：

std::vector<std::string> v;
//参数为左值引用
void func_push(const std::string& str)
{
    std::cout << "左(const std::string& str)" << std::endl;
    v.push_back(str);

}
//参数为右值引用
void func_push(std::string&& str)
{
    std::cout << "右(std::string&& str)" << std::endl;
    v.push_back(std::move(str));
}
//参数为万能引用的模板函数
template<class T>
void func(T&& t)
{
    //调用func_push()函数    
    func_push(t);
}
//测试
void test3()
{
    std::string s = "123";
    func(s);
    func(std::move(s));         //std::move(s)是一个亡值表达式, 返回的是一个右值传入给func函数
}

 运行结果为：

 分析：

  1. s为一个左值，经过模板T的推导，t是一个左值引用。所以会运行func_push(const std::string& str)；
  2. 而move(s)的作用是将左值强制转化为右值，那按照引用折叠进行推导，t应该是一个右值引用才对，但根据运行结果来看，还是执行的左值引用的函数，原因是：t虽然是个右值引用，但是它本身是一个左值，所以依然会调用左值引用的函数。

我们希望的是左值引用就调用左值引用函数，右值引用就调用右值引用的函数，现在达不到目的。若是再次强行将模板函数里的t转换为右值，即：

template<class T>
void func(T&& t)
{
//    func_push(t);									// 
    func_push(std::move(t));
}

void test3()
{
    std::string s = "123";
    func(s);
    func(std::move(s));         
}

运行结果为：

 

 很明显，因为经过move()后，两个都会调用右值引用的函数，那么现在就轮到完美转发出场了。

格式：template <class T>   forward<T>()

#include<iostream>
#include<vector>


std::vector<std::string> v;
void func_push(const std::string& str)
{
    std::cout << "左(const std::string& str)" << std::endl;
    v.push_back(str);

}
void func_push(std::string&& str)
{
    std::cout << "右(std::string&& str)" << std::endl;
    v.push_back(std::move(str));
}
template<class T>
void func(T&& t)
{
    func_push(std::forward<T>(t));//加入完美转发
}

 int main()
{
    std::string s = "123";
    func(s);
    func(std::move(s));         //std::move(s)是一个亡值表达式, 返回的是一个右值传入给func函数
}

 运行结果为：

 完美转发的源码如下：

template<typename _Tp>
constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ 
    return static_cast<_Tp&&>(__t);
}
template<typename _Tp>
constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
    static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument substituting _Tp is an lvalue reference type");
    return static_cast<_Tp&&>(__t);
}
template<typename _Tp>
struct remove_reference
{ 
    typedef _Tp   type; 
};

template<typename _Tp>
struct remove_reference<_Tp&>
{ 
    typedef _Tp   type; 
};

template<typename _Tp>
struct remove_reference<_Tp&&>
{ 
    typedef _Tp   type; 
};

3、可变参数模板

3.1、基本语法

C++11的可变参数模板对参数进行了高度泛化，可以表示任意数目、任意类型的参数，其语法为：在class或typename后面加上省略号“...”。

例如：（其中T叫做模板参数包，args叫做函数参数包）

#include<iostream>
#include<vector>
using namespace std;

template<class ...T>
void func(T ...args) {
    cout << "参数包中参数的个数为：" << sizeof ...(args) << endl;
}

int main() {
    func();//参数包里0个参数
    func(1, 2, 3);//参数包里3个int型的实参
    func(1, "hello", 2.0);//参数包里一个int型的实参，一个char型的实参，一个double型的实参
    return 0;
}

运行结果为：

 省略号的作用：

  1. 声明一个包含0到任意个模板参数的参数包；
  2. 在模板定义的右边，可以将参数包展开为一个个独立的参数

3.2、参数包的展开

3.2.1、递归函数

 C++11可以使用递归函数的方式展开参数包，获得可变参数的每个值。通过递归函数展开参数包，需要提供一个参数包展开的函数和一个递归终止函数。

例如：

#include<iostream>
#include<vector>
using namespace std;


//最终递归函数
void print() {
    cout << "empty" << endl;
}
//展开函数
template<typename T, typename ...Args>
void print(T head, Args ...args) {
    cout << head << ",";
    print(args...);
}
int main() {
    print(1,2,3,4);
    return 0;
}

运行结果为：

参数包Args...在展开的过程中递归调用自己，每调用一次，参数包中的参数就会少一个 ，直到所有的参数都展开为止。当没有参数时就会调用非模板函数print()来终止递归过程。

 3.2.2、逗号表达式

 通过逗号表达式的方式展开参数包是不需要设置终止递归函数的，其直接在expand函数体中展开。

例如：（print（）不是终止函数，只是一个处理参数包中每一个参数的函数）

#include<iostream>
#include<vector>
using namespace std;

template<class T >
void printf(T t) {
    cout << t<< endl;
}
//展开函数
template<class ...Args>
void print(Args ...args) {
    int arr[] = { (printf(args),0)... };
    cout << endl;
}
int main() {
    print(1,2,3,4);
    return 0;
}

运行结果为：

 

 4、Lambda表达式

 4.1、概念

Lambda表达式实际上是定一个匿名的函数，该类由编译器lambda创建，这个函数被隐式地定义为内联，可以捕获一定范围内的变量。因此，调用lambda表达式相当于直接调用它的operator()函数，这个函数可以被编译器内联优化，其语法如下：

[capture](params)mutable->return-type{statement}

 其中：

  1. [capture]：为捕获列表，捕获上下文变量供lamba使用，[]表示一个lambda的开始，不可省略，编译器会根据该符号来判断接下来的代码是不是lambda表达式。
  2. （params）：为参数列表，与普通函数的参数列表一致，如果不需要传递参数，则可以连括号一起省略。可以按值和按引用两种方式传参。
  3. mutable：为修饰符，默认情况下，lambda函数总是一个const函数，mutable可以取消常量-性。注意：在使用mutable时，参数列表不可以省略。
  4. ->return->type：是返回值类型。当函数返回值为void，或者函数体只有一处return的地址时，这部分可以省略，因为只有一处return时，编译器可以自动推断出返回类型。
  5. {statement}：函数体，内容和普通函数一样，除了可以使用参数外，还可以使用所捕获的变量。此部分函数体可以为空，但不能省略。

 4.2、使用方法

Lambda表达式与普通函数最大的区别就是其可以通过捕获列表来访问一些上下文中的数据。

  • [var]：表示值传递方式捕获变量var；
  • [=]：表示值传递方式捕获所有父作用域的变量（包括this）；
  • [&var]：表示引用传递捕获变量var；
  • [&]：表示引用传递方式捕获所有父作用域的变量；
  • [this]：表示值传递方式捕获当前的this指针。

值传递示例：

#include<iostream>

using namespace std;

int main() {
    int x = 5;
    [x]() {
        cout << "捕获到的变量为：" << x << endl;
    }();
    cout << x+1 << endl;
    return 0;
}

 运行结果为：

注意：值传递时，lambda表达式是无法对其进行修改的。

要进行修改，就会报错：

 引用传递示例：

#include<iostream>

using namespace std;

int main() {
    int x = 5;
    [&x]() {
        cout << "捕获到的变量为：" << x++ << endl;
    }();
    cout << x+1 << endl;
    return 0;
}

运行结果为：

 注意：引用传递时可以对其值进行修改，并且在lambda内部修改了后，外部的值也会发生改变。

 用修饰符mutable的值传递示例：

#include<iostream>

using namespace std;

int main() {
    int x = 5;
    [x]()mutable {
        cout << "捕获到的变量为：" << ++x<< endl;
    }();
    cout << x<< endl;
    return 0;
}

运行结果为：

 可以看到，加了修饰符mutable之后，可以对值进行修改，而且在lambda内部修改的值，外部没有发生改变。

有返回值：

#include<iostream>

using namespace std;

int main() {
    const int ret = [] () {return 1024;}();
    /*const int ret = []()->int{return 1024;}();*/
    cout << ret << endl;
    return 0;
}

运行结果为：

 4.3、作用

Lambda表达式的类型被定义为“闭包”的类，其通常用于STL库中，在某些场景下可用于简化仿函数的使用，同时lambda表达式作为局部函数，也会提高复杂代码的开发速度，轻松在函数内重用代码，无需费心设计接口。

Pumpkin_O
关注
专栏目录
C++11新特性.pdf
09-14
C++11新特性 C++11是一个重要的升级版本，它引入了许多新特性，极大地提高了C++语言的表达能力和效率。下面将对C++11的一些新特性进行详细介绍。 一、nullptr nullptr是一个C++关键字，它是空指针常量，用来替代...
深入理解C++11新特性解析与应用.pdf
03-12
深入理解C++11：C++11新特性解析与应用》主要内容：[0国0]内[0首0]本全面深入解读C++11新标准的专著，由C++标准委员[0会0]代表和IBM XL编译器中[0国0]开发团队共同撰写。不仅详细阐述了C++11标准的设计原则，而且...
C++11 新特性
TABE_的博客
03-09 2844
这里写目录标题“语法糖”auto自动类型推导lambda表达式右值引用与移动语义右值引用移动语义完美转发 Perfect Forwarding智能指针C++11多线程编程 目前用到过的C++11新特性主要分为以下四个方面： “语法糖”： auto自动类型推导，初始化列表, lambda表达式等。 右值引用和移动语义 智能指针 C++11多线程编程：thread库 “语法糖” auto自动类型推导 C语言也有auto关键字，但是其含义只是与static变量做一个区分，一个变量不指定的话默认就是auto。因
c++11新特性
wangzai32100的博客
07-28 5301
在传统C头文件(stddef.h)中的定义如下。
C++11新特性
冯同学的博客
07-02 5535
C++11新特性
C++11新特性总结
热门推荐
小杰312的博客
02-22 2万+
C++11新特性总结
c++面试之c++11新特性
weixin_45249333的博客
04-22 1298
c++面试之c++11新特性，智能指针，移动语义和完美转发，lambda表达式，final和overide关键字，左值右值，auto和decltype关键字,default关键字，const和constexpr关键字
C++ | C++11新特性解析：现代编程的里程碑
LiHongyu05的博客
08-14 1781
在2003年，C++标准委员会提交了一份技术勘误表（TC1），使得C++03成为C++98之后的最新标准。然而，C++03主要是对C++98标准中的漏洞进行修复，语言的核心部分并没有大的改动。因此，人们通常将这两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准经过了长达十年的发展，带来了约140个新特性和对C++03标准中约600个缺陷的修正。这使得C++11更像是从C++98/03中孕育出的一种新语言。
C++ 11新特性详解
qq_61635026的博客
10-02 3139
在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，
C++11新特性之nullptr
Serven的博客
05-21 4564
C++11新特性之nullptr
C++11新特性一览 - 引自《C++ Primer》
weixin_53833977的博客
04-18 1万+
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可
C++11新特性之for循环
Serven的博客
05-26 4145
C++11新特性之for
深入理解C++11：C++11新特性解析与应用.rar_C++11新特性_C++11特性说明_深入应用 C++11_深入理解 c
07-14
能较好的说明C++11的特性，起到较好说明功能
C++ 11新特性之大括号初始化详解
01-01
本文主要给大家介绍了关于C++11新特性之大括号初始化的相关内容，分享出来供大家参考学习，下面话不多说了，来一起看看详细的介绍： C++11之前，C++主要有以下几种初始化方式： //小括号初始化 string str(hello); ...
C++——C++11新语法（中）
最新发布
Wangx_wang的博客
11-06 567
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
xcx003的博客
11-02 594
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
杨辉三角——c语言
aqua3535742358的博客
11-05 389
define N 10 //自己定义输出行数。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 294
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
C++11新特性详解
"C++11新特性" C++11是C++编程语言的一个重大更新，引入了许多新的语言特性和库功能，极大地提高了代码的可读性、效率和安全性。以下是一些C++11的主要新特性： 1. **`__cplusplus` 宏**：在C++11中，`__cplusplus...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值