美文网首页
第二章 技术

第二章 技术

作者: szn好色仙人 | 来源:发表于2018-04-11 22:19 被阅读0次

编译期Assertions

//动态检测
#include <cassert>

template<typename TypeOut, typename TypeIn>
TypeOut safe_reinterpret_cast(TypeIn tIn)
{
    assert(sizeof(TypeIn) <= sizeof(TypeOut));
    return reinterpret_cast<TypeOut>(tIn);
}

int main()
{
    void* pValue = nullptr;
    char nValue0 = reinterpret_cast<char>(pValue);          //正常运行
    char nValue1 = safe_reinterpret_cast<char>(pValue);     //引发中断
    return 0;
}

//静态检测，但是编译器报的错并不直接

//结合常量表达式和编译器自动检查分配0数组错误
#define STATIC_CHECK(expr) { char aTem[expr ? 1 : 0]; }

template<typename TypeOut, typename TypeIn>
TypeOut safe_reinterpret_cast(TypeIn tIn)
{
    STATIC_CHECK(sizeof(TypeIn) <= sizeof(TypeOut));
    return reinterpret_cast<TypeOut>(tIn);
}

int main()
{
    void* pValue = nullptr;
    char nValue0 = reinterpret_cast<char>(pValue);               //编译通过

    //char nValue1 = safe_reinterpret_cast<char>(pValue);        //编译失败
    //error C2466: 不能分配常量大小为 0 的数组

    long long nValue2 = safe_reinterpret_cast<long long>(pValue);//编译成功
    return 0;
}

//最终版:检测任意常量表达式，且能自定义编译器报错的字符串

template<bool> class CCompileTimeCheck
{
public:
    CCompileTimeCheck(...);
};
template<> class CCompileTimeCheck<false> {};


#define STATIC_CHECK(expr, msg)                     \
{                                                   \
    class C##msg {};                                \
    sizeof((CCompileTimeCheck<expr> (C##msg())));   \
}


template<typename TypeOut, typename TypeIn>
TypeOut safe_reinterpret_cast(TypeIn tIn)
{
    STATIC_CHECK(sizeof(TypeOut) >= sizeof(TypeIn), Szn);

    return reinterpret_cast<TypeOut>(tIn);
}


int main()
{
    void* pValue = nullptr;
    long long nValue0 = safe_reinterpret_cast<long long>(pValue);//正常编译

    char nValue1 = safe_reinterpret_cast<char>(pValue);          //编译出错
/*  
    error C2440: “<function-style-cast>”: 
    无法从“safe_reinterpret_cast::CSzn”转换为“CCompileTimeCheck<false>”
*/
    return 0;
}

对象构造、函数声明、名称查找的规则组合体现的一个例子

#include <cstdio>
#include <typeinfo>


class CTest
{
public:
    CTest()             { printf("CTest\n"); }
    CTest(CTest&)       { printf("CTest Copy\n"); }
};

class CTest1
{
public:
    CTest1()            { printf("CTest1\n"); }
    CTest1(CTest&)      { printf("CTest1 Create\n"); }
    CTest1(CTest1&)     { printf("CTest1 Copy\n"); }
};


int main()
{
    {
        int nV0 = double(2.2);          //强制类型转换 nV0 = 2
        //反汇编: 008F3E2C  mov         dword ptr [nV0],2 

        int nV1 = (double)2.2;          //强制类型转换 nV1 = 2
        //反汇编: 008F3E33  mov         dword ptr [nV1],2  

        auto nV2 = int(double());       //强制类型转换 nV2 = 0
        //反汇编: 008F3E3A  mov         dword ptr [nV2],0  

        auto nV3 = static_cast<int>(double());
        //反汇编: 01003E25  mov         dword ptr [nV3],0  

        auto pStr = typeid(int(double())).name();
        //pStr = "int __cdecl(double (__cdecl*)(void))"

        pStr = typeid((int(double()))).name();
        //pStr = "int"

        pStr = typeid(double()).name();
        //pStr = "double __cdecl(void)"

        pStr = typeid((double())).name();
        //pStr = "double"


        //int (double);                 //编译失败
        int Fun(double);                //函数声明
        pStr = typeid(Fun).name();      //pStr = "int __cdecl(double)"

        //sizeof 需要一个表达式或类型
        //sizeof(Fun);  //error Cun2070: “int (double)”: 非法的 sizeof 操作数
        int nV4 = sizeof(Fun(1.1));     //Fun即使不进行定义，也不会报错 nV4 = 4
        //反汇编: 009C3ECD  mov         dword ptr [nV4],4  
    }

    {
        auto Test1 = CTest1(CTest());       //输出"CTest" "CTest1 Create"
        (CTest1(CTest()));                  //输出"CTest" "CTest1 Create"

        CTest1 CTest();                     //函数声明 
        CTest1 (CTest());                   //函数声明 等价上一句
        //从此 名字 CTest就不是自定义的类了，而是一个函数名称

        auto it = CTest1(CTest());  //输出"Suprise" "CTest1" "CTest1 Copy"
        auto it1 = CTest();         //输出"Suprise" "CTest1"

        printf("");
    }

    return 0;
}


CTest1(CTest())     //等价于 CTest1 CTest() 此段代码是是CTest函数的定义
{
    printf("Suprise\n");

    return CTest1();
}

模板偏特化

  • 模板类可以全特化也可以偏特化
  • 模板类的成员函数只能全特化，不能偏特化(参见第一章)
  • namespace-level的函数不能偏特化，但是可以被轻易的重载

常数映射为类型

  • 应用场景:
    有必要根据某个编译期常数调用一个或数个不同的函数
    编译期实施分派(if-else switch语句)
template<int nValue>
struct IntToType
{
    enum { eValue = nValue };
};


template<typename T, bool bTest>
class CTest
{
public:
    void Fun()
    {
        //编译期分派
        if (bTest)
        {
            tValue.SomeFun();
        }
    }

private:
    T tValue;
};

template<typename T, bool bTest>
class CTest1
{
private:
    void Fun(IntToType<true>)
    {
        tValue.SomeFun();
    }

    void Fun(IntToType<false>){}

public:
    //编译期分派
    void Suprise()
    {
        Fun(IntToType<bTest>());
    }

private:
    T tValue;
};


int main()
{
    int nValue = 10;
    auto it0 = IntToType<10>();         //编译成功
    //auto it1 = IntToType<nValue>();   //编译出错
    //“IntToType”: 模板参数“nValue”:“nValue”: 局部变量不能用作非类型参数

    CTest<int, false> Test;
    //Test.Fun();               //编译出错

    CTest1<int, false> Test1;
    Test1.Suprise();            //编译成功
    return 0;
}

类型对类型的映射

//类型映射到类型
template<typename T>
struct STypeToType{ typedef T TypeOriginal; };

template<typename T, typename U>
T* Create(const U& u, STypeToType<T>)
{
    return new T(u);
}

template<typename U>
CTest* Create(const U& u, STypeToType<CTest>)
{
    //根据类型定制的版本
    return new CTest(u, -1);
}

型别选择

  • 一个应用场景:比如根据不同的类型，在vector中选择放置对象本身还是对象的指针
#include <vector>
#include <typeinfo>


using std::vector;


//方法一:扩展性差
template<typename T, bool bRe>
struct STest
{
    typedef T* Type;
};

template<typename T>
struct STest<T, false>
{
    typedef T Type;
};


//方法二:扩展性好
template<bool bRe, typename T, typename U>
struct SSelect
{
    typedef T Type;
};

template<typename T, typename U>
struct SSelect<false, T, U>
{
    typedef U Type;
};


int main()
{
    //it0 = "int *"
    auto it0 = typeid(STest<int, true>::Type).name();

    //it1 =  "int"
    auto it1 = typeid(STest<int, false>::Type).name();

    //it2 = "int"
    auto it2 = typeid(SSelect<true, int, double>::Type).name();

    //it3 = "double"
    auto it3 = typeid(SSelect<false, int, double>::Type).name();    
    
    return 0;
}

编译期间侦查可转换性和继承性

  • 面对两个陌生的类型T和U，如何得知U是否继承于T？在编译期间发掘这样的关系，意味着不必使用dynamic_cast，后者会所耗执行效率。
template<typename T, typename U>
class CConversion
{
    //此类可以用于编译期间侦测类型的可转换性

    typedef char Small;
    class CBig { char aBuff[2]; };
    //定义class CBig { char aBuff[2]; }; 确保sizeof(CBig) != sizeof(Small)

    static Small Fun(U);
    static CBig Fun(...);
/*
    若T能转换为U则调用Fun(U), 否则调用Fun(...)
    则有如下结论:
    若T能转换为U : Fun返回Small
    若T不能转换为U : Fun返回CBig
*/

    static T MakeT();
    //定义一个不完全函数，即使T类型的构造函数是private类型的也无妨

public:
    enum 
    {
        eExists = sizeof(Fun(MakeT())) == sizeof(Small)
        //若T能转换为U则      Exists = true
        //若T不能转换为U则 Exists = false

/*
        sizeof可以用在任何表达式上，不论后者有多复杂，sizeof会直接传回大小，
        不需要等到执行期才评估。这意味着sizeof可以感知重载、模板具现、转换规则
        ，或任何可以发生在C++表达式上的机制
*/
    };

    enum
    {
        eExistsToWay = eExists && CConversion<U, T>::eExists
    };

    enum
    {
        eSameType = false
    };
};


//模板偏特化
template<typename T>
class CConversion<T, T>
{
public:
    enum { eExists = true, eExistsToWay = true, eSameType = true };
};


class CFather {};
class CChild : public CFather {};


int main()
{
    bool aRe0[] = 
    {
        CConversion<double, int>::eExists,      //true
        CConversion<int, char*>::eExists,       //false
        CConversion<CChild*, CFather*>::eExists,//true
        CConversion<CFather*, CChild*>::eExists,//false
    };

    bool aRe1[] = 
    {
        //true
        CConversion<double, int>::eExistsToWay,

        //false
        CConversion<CChild*, CFather*>::eExistsToWay,

    };

    bool aRe2[] =
    {
        CConversion<int, int>::eSameType,       //true
        CConversion<int, double>::eSameType,    //false
    };

    return 0;
}

Type Traits

//类型判断

#include <vector>
using std::vector;


template<typename T>
class CTypeTraits
{
public:
    enum
    {
        eNormal,
        eNference,
        eNormalPoint,
        ePointToMember,
    };

private:
    template<typename U> struct STypeTest
    {
        enum { eResult = eNormal };
    };

    template<typename U> struct STypeTest<U&>
    {
        enum { eResult = eNference };
    };

    template<typename U> struct STypeTest<U* const>
    {
        enum { eResult = eNormalPoint };
    };

    template<typename U> struct STypeTest<U*>
    {
        enum { eResult = eNormalPoint };
    };

    template<typename U, typename V>
    struct STypeTest<U V::*>
    {
        enum { eResult = ePointToMember };
    };

    template<typename U, typename V>
    struct STypeTest<U (V::*)() const>
    {
        //类的常量 成员/成员函数 指针
        enum { eResult = ePointToMember };
    };

public:
    enum { eType = STypeTest<T>::eResult };
};


struct A
{
    int value;
    int Fun();
};


int main()
{
    //语法 : 定义一个指向类的常量成员函数的指针
    vector<int>::size_type (vector<int>::*p)() const = &vector<int>::size;

    char aRe[] = 
    {
        CTypeTraits<vector<char>::iterator>::eType, //0
        CTypeTraits<char>::eType,                   //0
        CTypeTraits<char&>::eType,                  //1
        CTypeTraits<char* const>::eType,            //2
        CTypeTraits<char*>::eType,                  //2
        CTypeTraits<decltype(&A::value)>::eType,    //3
        CTypeTraits<decltype(&A::Fun)>::eType,      //3
        CTypeTraits<decltype(&vector<int>::size)>::eType,       //3
    };

    return 0;
}

//利用偏特化 去掉 const 属性
template<typename T>
class CDelConst
{
private:
    template<typename U> struct SNotConst
    {
        typedef U Type;
    };

    template<typename U> struct SNotConst<const U>
    {
        typedef U Type;
    };

public:
    typedef typename SNotConst<T>::Type Type;
};

相关文章

  • 《科学学习的理论与实践》笔记10

    【觉察日记】 《破解高效学习的密码》笔记：第二章：元认知高效学习五维调控技术简介/技术原理（P15-019） 心理...

  • 第二章 技术

    编译期Assertions 对象构造、函数声明、名称查找的规则组合体现的一个例子 模板偏特化 模板类可以全特化也可...

  • NLP自然语言处理-第二章NLP前置技术解析

    第二章NLP前置技术解析 [toc] 在本章中，你将学到 NLP相关的一些前置技术 很多的数据科学库、框架 、模块...

  • 漫读《变量》 -3-

    第二章《在无人地带寻找无人机》 -1- 除了极少数石破天惊的突破性技术外，大部分技术都是已有技术的“混搭”。……技...

  • 一电子信息工程专业课:电子导论

    我的大学课程 第二章 现代电子技术 电子发烧友附上 http://m.elecfans.com/ 电子技术设计网直...

  • 魂之若风（第二章）

    第二章 “咱这技术，就像风。看不见摸不到，但是，如影随形。” 这是方博刚做技术兵还觉着自己牛气哄哄的时候，嘴上常挂...

  • 《管理百年》读书笔记（三）

    第二章 技术，给效率插上翅膀 福特公司创始人亨利•福特在管理上强调技术对工人、对企业的重要性。他注重分工，...

  • 《掌控谈话》第二章读书笔记

    一、读书摘要（第二章）本章介绍了几种主动倾听的技术，包括重复、沉默和使用深夜电台主持人的声音。这些技术可以有效避免...

  • 日更-《创新者的窘境》读书笔记05

    第二章技术 S 形曲线是指，只要在一定时期内，产品的性能就可能会随着技术的成熟而发生变化。也就是在技术发展早期，性...

  • 福特之路的启示

    邯郸四中 张建新 读克雷纳《管理百年》第二章《技术，给效率插上翅膀》，通过学习福特之路，认识到先进的技术可以极大...

网友评论

      本文标题：第二章 技术

      本文链接：https://www.haomeiwen.com/subject/shnzhftx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|第二章 技术|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！