C++ 11/14 1

最新推荐文章于 2025-08-07 09:30:23 发布

转载最新推荐文章于 2025-08-07 09:30:23 发布 · 381 阅读

文章标签：

#c语言

语言学习专栏收录该内容

20 篇文章

订阅专栏

variadic template parameter
Ranged for
initializer list
Explicit Ctor
补充 1.对象序列化（boost） 2. base64 编码 3.constexpr,auto,decltype 关键字 4. OOA,OOD,OOP,ATL概念 5.bitset 6.内部连接外部连接

variadic template parameter

实现不定类型数量参数打印

void print(){}//结束条件
template<typename T,typename... Types>
void print(const T& firstarg, const Types&... args)
{
    cout << firstargs << endl;
    print(args);
}
test: print(1,1.9,"aas");

实现万用hash

class CustomerHash {
public:
    std::size_t operator()(const Customer& c) const {
    return hash_val(c.fname, c.lname, c.no);
}
};

//1.
template<typename... types>//不定参模板
inline size_t hash_val(const Types&... args) {
    size_t seed=0;
    hash_val(seed,args...);
    return seed;
}
//2.
template<typename T, typename... Types>
inline void hash_val(size_t& seed, const T& val,const Types&... args) {
    hash_combine(seed,val);
    hash_val(seed,args);
}
//3.结束函数
template<typename T>
inline void hash_val(size_t& seed, const T& val)
{
    hash_combine(seed,val);
}

template<typename T>
inline void hash_combine(size_t& seed, const T&val){
    seed^=std::hash<T>()(val) +0x9e3779b9 + (seed<<6) +(seed>>2);//0x9e3779b9 黄金分割率
}

实现tuple

template<typename... Values> class tuple;
template<> class tuple<> {};

template<typename Head, typename... Tail>
class tuple<Head,Tail...>:private tuple<Tail...>
{
    typedef tuple<Tail...> inherited;
public:
    tuple(){}
    tuple(Head v, Tail...vtail):m_head(head), inherited(vtail...) {}
    Head head() {return m_head;}
    inherited& tail() {return *this;}
protected:
    Head m_head;
};
//example
tuple<int, float, string> t(41, 6.3, "nico");
t.head()；//得到41
t.tail();// 得到inherited 类型tail
t.tail().head();// 得到6.3

构造时从右往左构造tuple< > – >tuple < string >– >tuple< float,string >

Ranged for

形式 for (decl : coll) {
statement
}

vector<int> vec {1,2,3,4};
for (auto elem: vex){
    cout << elem << endl;
}

for(auto& elem : vec){
    elem *= 2;
}
for (int i :{1,2,3,4,5}){
    cout << i << endl;
}

initializer list

int i;//无默认值
int j{}//有默认值
int* p;//无默认值
int* p{};//有默认值
int p{5.3};//error 不允许narrow

编译器自动将{}构造为一个initilizer_list 并将其内容分发给相应的构造函数。当不存在initializer_list 构造函数时，{} 中的初始化内容将被对应为为已有的对应构造函数中。若还不满足则编译失败。

#include <initializer_list>
class TestInitializerList
{
public:
    TestInitializerList(int a,int b):m_a(a),m_b(b){
    }
    TestInitializerList(std::initializer_list<int> vals){
        for (auto item ：vals)
            cout << item;
    }
};
Test: TestInitializerList t1 {1,2};
        TestInitializerList t2 {1,2,3,4};
//当两个构造函数都存在时调用第二个，当只有第一个构造函数时t1调用第一个t2编译失败，此时修改t2{{1,2},{3,4}}可以通过

原理: 编译器自动构造一个array< T ,n >自动调用initializer_list实现上述功能。
实现：

template <class _E>
class initializer_list
{
public:
    typedef _E value_type;
    typedef const _E& reference;
    typedef const _E& const_reference;
    typedef size_t size_type;
    typedef const _E* iterator;
    typedef const _E* const_iterator;
private:
    iterator _M_array;
    size_type _M_len;
    // Compiler can call a private constructor
    constexpr initializer_list(const_iterator __a, size_type __l):_M_array(__a),_M_len(__l){}
public:
    constexpr initializer_list():_M_array(0),_M_len(0) noexcept {}
    constexpr size_type size() const noexcept {return _M_len;}
    constexpr const_iterator begin() const noexcept {return _M_array;}
    constexpr const_iterator end() {return begin() + _M_len;}
};

C++11中vector,deque,array,set,list,foward_list,map均提供了这种初始化方式，包括insert,operator=,assign等。

Explicit Ctor

#include <initializer_list>
class TestInitializerList
{
public:
    explicit TestInitializerList(int a,int b，int c):m_a(a),m_b(b){
    }
    TestInitializerList(std::initializer_list<int> vals){
        for (auto item ：vals)
            cout << item;
    }
};
Test: TestInitializerList t1 {1,2,3};

此时编译失败转化。(vs2017可以编译通过)（此处根据编译器实现不同而不同vs 2017 只要存在initializer_list 就会调用initializer_list 版本构造函数，）

补充 1.对象序列化（boost） 2. base64 编码 3.constexpr,auto,decltype 关键字 4. OOA,OOD,OOP,ATL概念 5.bitset 6.内部连接外部连接

1.对象序列化
boost serialization 库

#inlcude <boost/archive/text_iarchive.hpp>
#inlcude <boost/archive/text_oarchive.hpp>
#include <iostream>
#include <fstream>
void save()
{
    std::ofstream file("archive.txt");
    boost::archive::text_oarchive oa(file);
    std::string s = "save test\n";
    oa & s; // samw with oa << s; 
}

void load()
{
    std::ifstream file("archive");
    boost::archive::text_iarchive ia(file)
    std::string s;
    ia & s;//same with ia >> s;
}

若想保存到XML 中则头文件更换为xml_iarchive.hpp/xml_oarchive.hpp
oa & BOOST_SERIALIZATION_NVP(s);
ia & BOOST_SERIALIZATION_NVP(s);

转存数组需要提前指定数组大小。转存STL 容器不需要指定大小，转存自定义类需要在类中定义一个serialize方法供归档时调用

template<class Archive>
void serialize(Archive& archive,const unsigned int version)
{
    archive & BOOST_SERIALIZATION_NVP(private_data);
    ...
}

或者非侵入性版本

template<class Archive>
void serialize(Archive& archive,date& d, const unsigned int version)
{
    archive & BOOST_SERIALIZATION_NVP(private_data);
    ...
}

2.base64编码
参考：
http://www.cnblogs.com/chengmo/archive/2014/05/18/3735917.html
3.constexpr
const 变量的初始化可以延迟到运行时，而 constexpr 变量必须在编译时进行初始化。
在C++11中，我们可以声明某些函数是常量表达式，这样的函数必须在编译期间计算出它们的值，这样的函数必须满足以下条件：

返回值和参数必须是Literal类型
函数体必须只包含一个return语句
函数提可以包含其他的语句，但是这些语句不能在运行期起作用
函数可以不返回常量，但是在调用的时候实参必须传入常量表达式
http://blog.youkuaiyun.com/csxiaoshui/article/details/39473419

auto
参考：
http://blog.youkuaiyun.com/huang_xw/article/details/8760403
dcltype:
参考：
http://blog.youkuaiyun.com/yshe_xun/article/details/7315135
4. OOA,OOD,OOP,ATL概念
参考：http://www.cnblogs.com/niexiaobo/p/4884706.html
http://blog.youkuaiyun.com/xdrt81y/article/details/17143135
5.bitset
http://blog.youkuaiyun.com/qll125596718/article/details/6901935
http://blog.youkuaiyun.com/u012069890/article/details/59108840
6.内部连接外部连接
http://blog.youkuaiyun.com/xiexievv/article/details/8491494
http://developer.51cto.com/art/201107/277364.htm
http://bbs.youkuaiyun.com/topics/390495702
http://blog.youkuaiyun.com/sruru/article/details/7951019