【深入理解C++11：C++新特性解析】第5章 提高类型安全 测试代码整理

最新推荐文章于 2023-12-30 16:24:06 发布
最新推荐文章于 2023-12-30 16:24:06 发布
阅读量386 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Edidaughter/article/details/112559875
版权

目录

 

5-1.通过namespace分割了全局空间但是namespace中的成员依旧被enum成员污染的举例

5-2.枚举成员被隐式转换之后无法通过编译的例子

5-3.用令人眼花缭乱的方法封装不同的枚举类达到避免被隐式转换的目的

5-4.编译器会更具数据类型的不同对enum应用不同的数据长度

5-5.用一个例子来说明强制枚举类型的用法

5-6.为强类型枚举显式指定底层基本类型保证各编译器输出一致

5-7附近.C++11中枚举类型在作用域做了拓展

5-7.由于enum class是强类型作用域的,所以匿名的enum class很可能什么也做不了

5-8.一个简单说明C++11中的智能指针unique_ptr和shared_ptr使用方法的例子

5-9.一个简单说明C++11中的智能指针weak_ptr使用方法的例子

5-10.一个简单说明移动指针可能触发垃圾回收的例子

5-11.什么时候会触发垃圾回收机制呢？这个代码是不可控不安全的

5-12.declare_reachable显式告诉垃圾回收器不要去回收对应内存

5-1.通过namespace分割了全局空间但是namespace中的成员依旧被enum成员污染的举例

#include <iostream>
using namespace std;
namespace T{
     enum Type{General,Light,Medium,Heavy};
}

namespace {
     enum Category{General = 1,Pistol,MachineGun,Cannon};
}
int main(){
    T::Type t = T::Light;
    if( t == General) // 忘记使用namespace
        cout<<"General Weapon" << endl;
    return 0;
}
/*
   编译选项：g++ -std=c++11 5-1-1.cpp
   代码清单: 5-1
   代码功能：通过namespace分割了全局空间但是namespace中的成员依旧被enum成员污染的举例
*/

5-2.枚举成员被隐式转换之后无法通过编译的例子

#include <iostream>
using namespace std;

enum Type{General,Light,Medium,Heavy};

// enum Category{Pistol,MachineGun,Cannon}; // 无法编译通过，重复定义
enum Category{Pistol,MachineGun,Cannon};

struct Killer{
    Killer(Type t,Category c):type(t),category(c){}
    Type type;
    Category category;
};
int main(){
    Killer cool(General,MachineGun);
    if(cool.type >= Pistol) // 用错类型了，g++下会报警告，但是能够编译通过
            cout << "It is not a pistal" << endl;
    cout << is_pod<Type>::value << endl;     // 1
    cout << is_pod<Category>::value << endl; // 1
    return 0;
}
/*
   编译选项：g++ -std=c++11 5-1-1.cpp
   代码清单: 5-2
   代码功能：通过namespace分割了全局空间但是namespace中的成员依旧被enum成员污染的举例
*/

5-3.用令人眼花缭乱的方法封装不同的枚举类达到避免被隐式转换的目的

#include <iostream>
using namespace std;
class Type{
   public:
        enum type{general,light,medium,heavy};
        type val;
    public:
         Type(type t):val(t){}
         bool operator >=(const Type & t) {return val>= t.val}
         static const Type General,Light,Medium,Heavy;
};
const Type Type::General(Type::general);
const Type Type::Light(Type::light);
const Type Type::Medium(Type::medium);
const Type Type::Heavy(Type::heavy);

class Category{
    public:
        enum category{pistol,machineGun,cannon};
        category val;
    public:
        Category(category c):val(c){}
        bool operator >= (const Category &c){return val >= c.val;}
        static const Category Pistol,MachineGun,Cannon;   
};
const Category Category::Pistol(Category::pistol);
const Category Category::MachineGun(Category::machineGun);
const Category Category::Cannon(Category::cannon);

struct Killer{
    Killer(Type t,Category c):type(t),category(c){}
    Type type;
    Category category;
};

int main(){
    Killer notCool(Type::General,Category::MachineGun);// 使用类型包装后的enum
    if(notCool.type >= Type::General) 
        cout <<"It is not general" <<endl;
    //if(notCool.type >= Category::Pistol) // 此处编译不能通过
    //    cout <<"It is not pistal" <<endl;
    cout << is_pod<Type>::value << endl;
    cout << is_pod<Category>::value << endl;
    return 0;
}

/*
   编译选项：g++ -c 5-1-3.cpp -c -std=c++11
   代码清单: 5-3
   代码功能：用令人眼花缭乱的方法封装不同的枚举类达到避免被隐式转换的目的
*/

5-4.编译器会更具数据类型的不同对enum应用不同的数据长度

#include <iostream>
using namespace std;
enum C {C1=1,C2 = 2};
enum D {D1=1,D2 = 2,Dbig = 0xFFFFFFF0u};
enum E {E1=1,E2 = 2,Ebig = 0xFFFFFFFFFLL};
int main(){
    cout << sizeof(C1)<<endl;   // 4
    cout << Dbig<<endl;         // 不同的编译器输出可能不同,g++输出4294967280,Visyual C++输出-16
    cout << sizeof(D1)<<endl;   // 4
    cout << sizeof(Dbig)<<endl; // 4
    cout << Ebig<<endl;         // 68719476735
    cout << sizeof(E1)<<endl;   // 8
    return 0;
}

/*
   编译选项：g++ -c 5-1-4.cpp -c -std=c++11
   代码清单: 5-4
   代码功能：编译器会更具数据类型的不同对enum应用不同的数据长度
*/

5-5.用一个例子来说明强制枚举类型的用法

#include <iostream>
using namespace std;
enum  class Type{General,Light,Medium,Heavy};
enum  class Category{General=1,Pistol,MachineGun,Cannon};
int main(){
   Type t = Type::Light;
   t = General;// 编译失败,必须使用强类型名称
   if(t == Category::General)// 编译失败，必须使用Type中的General
       cout << "General Weapon" <<endl;
   if(t>Type::General) // 通过编译
       cout << "Not General Weapon" <<endl;
   if(t > 0)           // 编译失败，无法隐式转化为int类型                       
       cout << "Not General Weapon" <<endl;
   if((int)t > 0)      // 通过编译
      cout << "Not General Weapon" <<endl;
   cout << is_pod<Type>::value << endl;
   cout << is_pod<Category>::value << endl;
   return 0;
}
/*
   编译选项：g++ -c 5-1-5.cpp -c -std=c++11
   代码清单: 5-5
   代码功能：用一个例子来说明强制枚举类型的用法
*/

5-6.为强类型枚举显式指定底层基本类型保证各编译器输出一致

#include <iostream>
using namespace std;
enum class C:char {C1=1,C2 = 2};
enum class D:unsigned int {D1=1,D2 = 2,Dbig = 0xFFFFFFF0u};

int main(){
    cout << sizeof(C:C1)<<endl;   // 1
    cout << (unsigned int)D::Dbig<<endl;  // 编译器输出一致，4294967280     
    cout << sizeof(D:D1)<<endl;   // 4
    cout << sizeof(D:Dbig)<<endl; // 4
    return 0;
}

/*
   编译选项：g++ -c 5-1-6.cpp -c -std=c++11
   代码清单: 5-6
   代码功能：为强类型枚举指定底层基本类型保证各编译器输出一致
*/

5-7附近.C++11中枚举类型在作用域做了拓展

enum Type{G,L,M,H};
Type t1 = G;
Type t2 = Type::G;

/*
   编译选项：g++ -c 5-1-7-1.cpp -c -std=c++11
   代码清单: 5-7附近的例子
   代码功能：C++11中枚举类型在作用域做了拓展
*/

 

5-7.由于enum class是强类型作用域的,所以匿名的enum class很可能什么也做不了

enum class {General,Light,Medium,Heavy} weapon;
int main(){
    weapon = General;
    bool b = (weapon == weapon::General);
    return 0;
}
/*
   编译选项：g++ -c 5-1-7-2.cpp -c -std=c++11
   代码清单: 5-7
   代码功能：由于enum class是强类型作用域的,所以匿名的enum class很可能什么也做不了
*/

5-8.一个简单说明C++11中的智能指针unique_ptr和shared_ptr使用方法的例子

#include <memory>
#include <iostream>
using namespace std;
int main(){
   unique_ptr<int> up1(new int(11));// 无法复制的unique_otr
   //unique_ptr<int> up2 = up1;     // 不能通过编译
   cout <<*up1<<endl;               // 11
   unique_ptr<int> up3 = move(up1); // 现在的up3是数据唯一的unique_ptr智能指针
   cout<< *up3 <<endl;              // 11
  //cout<< *up1 <<endl;             // 运行时错误 
   up3.reset();                     // 显示释放内存 
   up1.reset();                     // 不会导致运行时错误
  // cout<< *up3 <<endl;            // 运行时错误

   shared_ptr<int> sp1(new int(22));
   shared_ptr<int> sp2 = sp1;
   cout<< *sp1 <<endl;               // 22
   cout<< *sp2 <<endl;               // 22
   sp1.reset(); 
   cout<< *sp2 <<endl;               // 22
   return 0;
}

/*
   编译选项：g++ 5-2-1.cpp -c -std=c++11
   代码清单: 5-8
   代码功能：一个简单说明C++11中的智能指针unique_ptr和shared_ptr使用方法的例子
*/

5-9.一个简单说明C++11中的智能指针weak_ptr使用方法的例子

#include <memory>
#include <iostream>
using namespace std;
void Check(weak_ptr<int> & wp){
     shared_ptr<int> sp = wp.lock();
     if( sp != nullptr)
        cout << "still " << *sp <<endl;
    else
        cout << "pointer is invalid." <<endl;
}



int main(){

   shared_ptr<int> sp1(new int(22));
   shared_ptr<int> sp2 = sp1;
   weak_ptr<int>  wp = sp1;
   cout<< *sp1 <<endl;               // 22
   cout<< *sp2 <<endl;               // 22
   Check(wp);                        // still 22
   sp1.reset(); 
   cout<< *sp2 <<endl;               // 22
   Check(wp);                        // still 22
   sp2.reset();                      // pointer is invalid.
   Check(wp);   
   return 0;
}

/*
   编译选项：g++  5-2-2.cpp -std=c++11
   代码清单: 5-9
   代码功能：一个简单说明weak_ptr使用方法的例子
*/

5-10.一个简单说明移动指针可能触发垃圾回收的例子

#include <iostream>
using namespace std;
int main(){
   int * p = new int;
   cout <<hex<<p << endl;
   p += 10;                // 移动指针，可能导致垃圾回收器对内存进行回收
   cout <<hex<<p << endl;
   p -= 10;                // 移动指针，可能导致回收原来指向的内存
   cout <<hex<<p << endl;
   *p = 10;                // 再次使用原来相同的指针可能无效，灾难性的，此处我的编译器上没有出错   
   cout <<dec<<*p << endl;
   return 0;
}
/*
   编译选项：g++ 5-2-3.cpp -std=c++11
   代码清单: 5-10
   代码功能：一个简单说明移动指针可能触发垃圾回收的例子
*/

5-11.什么时候会触发垃圾回收机制呢？这个代码是不可控不安全的

#include <unistd.h>
#include <iostream>
using namespace std;
int main(){
   int *p = new int;
   cout << hex << p <<endl;
   int *q = (int*)(reinterpret_cast<long long>(p)^2012);// q隐藏了p
   cout << hex << q << endl; // 做了一些其他工作，垃圾回收器可能已经回收了p指向的对象,什么时候会触发垃圾回收机制启动呢？
   q = (int*)(reinterpret_cast<long long>(q)^2012); // 用可逆的异或运算将p恢复回来，这里的p==q 
   cout << hex << q << endl;
   *q = 10;// 这里的*q=10可能是灾难性的
   cout << dec << *q << endl;
   return 0;
}
/*
   编译选项：g++ 5-2-4.cpp -std=c++11
   代码清单: 5-11
   代码功能：什么时候会触发垃圾回收机制呢？
*/

5-12.declare_reachable显式告诉垃圾回收器不要去回收对应内存

#include <memory>
using namespace std;
int main(){
   int *p = new int;
   declare_reachable(p); // 在p被隐藏之前声明为可达的
   int *q = (int*)((long long)p ^ 2012);
   q = undeclare_reachable<int>((int*)((long long)p ^ 2012));// 解除可达声明
   *q = 10; 
   return 0;
}
/*
   编译选项：g++ 5-2-5.cpp -std=c++11
   代码清单: 5-12
   代码功能：declare_reachable显式告诉垃圾回收器不要去回收对应内存
*/

 

 

 

 

我要精通C++
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【深入理解C++11】第五章 提高类型安全
柠檬柠檬C的博客
12-24 206
深入理C++115.1强类型枚举 5.1强类型枚举 普通枚举在全局区域存在相同的名字则会编译异常例如： enum Type{General, Light, Medium}; enum Category{General, Light, Medium}; C++11引入强类型枚举，即“枚举类”。 enum class Type{General, Light, Medium}; 他有以下几点优势： ...
C++11学习笔记5——提高类型安全
xiaoxiaoyusheng2012的专栏
01-30 730
1、强类型枚举          C++98中，枚举enum是非强作用域类型，enum的成员名字都是全局可见的。另外，由于C中枚举被设计为常量数值的“别名”的本性，枚举的成员总是可以被隐式地转换为整型。很多时候，这也是不安全的。          C++11中引入了强类型枚举（strong-typed enum），也就是将枚举封装成“枚举类”。 声明强类型枚举的方法：在enum后加上关键字
《深入理解C++11：C++11新特性解析与应用》笔记五
最新发布
Mamong's blog
12-30 671
深入理解C++11 第五章 提高类型安全
C++11中的智能指针和垃圾回收
m0_71009069的博客
01-30 1457
C++11中的智能指针和垃圾回收
C++11读书笔记—7（内存管理）
魔峥漫谈
08-04 1307
当你羡慕Java垃圾回收时，你想没想过java的垃圾回收机制靠C++实现的，而其实早先C++版本的实现。 其实C++的内存分配的难点不是把不该回收的回收了。而是有些不像指针的指针很容易识别不了。 一.垃圾回收方式简介 1.引用计数法(Reference Counting Collector) 　　引用计数法是唯一没有使用根集的垃圾回收的法，该算法
C++11与最小垃圾回收
风一样的男子（quinta）的博客
07-12 630
C++11新标准为了做到最小的垃圾回收支持，首先对“安全”的指针进行了定义，安全派生的指针是指向由new分配的对象或其子对象的指针。 安全派生指针的操作包括： 1：在解引用基础上的引用，比如：&*p。 2：定义明确的指针操作，比如p + 1。 3：定义明确的指针转换，比如：static_cast<void*>(p)。 4：指针和整型之间的reinterpret_cas...
C++11新特性
My__God的专栏
03-29 786
1.增加宏定义支持：增加C99预定义宏支持；__func__宏，代表当前所在函数的函数名；_Pragma，类似与#pragma，使用形式为_Pragma("xxxx")；__VA_ARGS__，变长函数实参名称。 2.增加了long long数据类似，长度与具体平台相关，但不低于为64位。 3.宏__cplusplus值修改为201103L，原标准中为199711L。 4.支持静态断言sta
DECLARE_DYNCREATE()的作用
youngandyang的博客
09-20 2287
一句话概括：就是为了是cobject的对象在运行的时候具备动态创建的能力，如果在类声明加入了这句，在类的实现中必有有对应的IMPLEMENT_DYNCREATE宏，发现frm、view、doc的类的实现里均有对应的IMPLEMENT_DYNCREATE宏 一、说明 DECLARE_DYNCREATE( class_name)和 IMPLEMENT_DYNCREATE(class_name,base...
C++11 智能指针与垃圾回收
qq_34552942的博客
08-27 1721
在实际的 C++ 开发中，我们经常会遇到诸如程序运行中突然崩溃、程序运行所用内存越来越多最终不得不重启等问题，这些问题往往都是内存资源管理不当造成的。比如： 有些内存资源已经被释放，但指向它的指针并没有改变指向（成为了野指针），并且后续还在使用； 有些内存资源已经被释放，后期又试图再释放一次（重复释放同一块内存会导致程序运行崩溃）； 没有及时释放不再使用的内存资源，造成内存泄漏，程序占用的内存资源越来越多。 C++ 虽然从来没有公开得支持过垃圾回收机制，但 C++98/03 标准中，支持使用 auto_p
杂货边角（26）：强枚举类型enum class
墨篙和小奶猫
02-28 631
枚举类型是C++从C继承而来的特性，但是枚举类型在C中的实现其实和宏无差别，即#define Male 0 #define Female 1 .... //用枚举声明为 enum {Male, Female}这种枚举类型和int整数的天然等价性很容易造成一些漏洞，如不同枚举名字域下的比较，并且传统的枚举类型中的符号是直接开发在父作用域中，这也容易导致符号冲突。而C++11引入的强枚举类型，非常好理解
C++：枚举类
~不可描述~
03-26 2149
枚举类定义l 语法形式enum class枚举类型名: 底层类型 {枚举值列表};l 例：enumclass Type { General, Light, Medium, Heavy}; enumclass Type: char { General, Light, Medium, Heavy}; enumclass Category { General=1, Pistol, MachineGu...
C++中的枚举类
Vergesson
02-14 764
枚举类定义 格式 enum class 枚举类型名：底层类型{枚举值列表}; 默认的底层类型是int型，但是新的C++标准中可以自定义底层类型。 如： enum class Type {General,Light,Medium,Heavy}; //底层类型默认是int型 enum class Type: char{General,Light,Medium,Heavy}; enum class Category{General=1,Pistol,MachineGun,Cannon}; 枚举类优势
is_POD_type
qq_57026262的博客
02-17 503
对于POD型别(与C结构体兼容或者标量型别)的数据类型，在拷贝或者构造时，可以直接按字节进行操作或者调用STL算法。而非POD型别的数据类型则必须调用它的非平凡的构造函数或者拷贝构造函数。 STL为各种基本类型定义了_type_traits模板类的特化版本，其中 typedef_true_type/_false_typeis_POD_type; 规定了此类型的POD型别(_true_type和_false_type是空结构体，因为模板的参数推导的运作必须保证它们是“类型”)； 而一些编译...
有缺陷的枚举类型 和 C++11中的强类型枚举
五月花
08-17 2813
首先第一点，我们要弄清一个概念，那就是枚举类型的名字都在其父作用域空间 可见的。举个例子就一目了然了。 enum Type { General, Light, Medium, Heavy }; enum Category{ General, Pistol, MachineGun, Cannon }; 由于Category中的General和Type中的General都是全局的名字，因此编译
宏定义污染的解决方法。
yanxiangtianji的专栏
04-07 2796
问题： 提要： mfc工程调用另一个基本c++工程出错（windows宏定义污染导致错误） 我用基本的C++配合STL写了一个库，编译成静态库lib。 又在同一个工作空间里面建立了个win32 console的工程，调用这个lib，一切正常。 然后我想加个界面，又建立了个基于对话框的mfc工程，用一样的方法include静态库工程的头文件，居然说我原来那个工程的文件语法有错，
C++基础(5) —— 前向引用声明、UML简介、结构体、联合体、枚举类
weixin_45926367的博客
02-15 1367
一、前向引用声明 类应该先声明，后使用； 如果需要在某个类的声明之前，引用该类，则应进行前向引用声明。 前向引用声明只为程序引入一个标识符，但具体声明在其他地方。 class B; //前向引用声明 class A{ public: void f(B b); }; class B{ public: void g(A a); } 前向引用声明注意事项 ...
C++学习笔记——基础（二）
sketchlcy的博客
03-23 273
两天时间重新复习C语言，对比C++来看会有更深刻的理解。 奶思~~ 学完这一章，想去搞开发哈哈哈哈
深入应用C++11：祁宇解析代码优化与工程实践
"深入应用C++11：代码优化与工程级应用，祁宇著，机械工业出版社出版，2015年5月第1版。" 《C++11 代码优化与工程级应用》这本书是作者祁宇针对C++11新标准编写的一本专业指南。C++11是C++编程语言的一个重大更新，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值