C++ 11 snippets , 1

1->创建7个Thread,跑个非常大的循环.观察CPU

void func(string &name)
{
    for(auto i=;i<0xFFFFFFFF;i++)
    {
        //cout << name << this_thread::get_id() << "running \n";
    }
}
int main()
{
    string thread_01_name("AThread");
    string thread_02_name("BThread");
    string thread_03_name("CThread");
    string thread_04_name("DThread");
    string thread_05_name("EThread");
    string thread_06_name("FThread");
    string thread_07_name("HThread");
 
    thread thread_01(func,ref(thread_01_name));
    thread thread_02(func,ref(thread_02_name));
    thread thread_03(func,ref(thread_03_name));
    thread thread_04(func,ref(thread_04_name));
    thread thread_05(func,ref(thread_05_name));
    thread thread_06(func,ref(thread_06_name));
    thread thread_07(func,ref(thread_07_name));
 
    thread_01.join();
    thread_02.join();
    thread_03.join();
    thread_04.join();
    thread_05.join();
    thread_06.join();
    thread_07.join();
 
}

2->Mutex

static int globNum = ;
mutex g_lock;
void func()
{
    g_lock.lock();
    std::cout << " going to in thread ID " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for((std::chrono::seconds()));
    std::cout << " leaving thread ID  " << std::this_thread::get_id() << std::endl;
    globNum += ;
    g_lock.unlock();
}
int main()
{
 
    std::thread t1(func);
    std::thread t2(func);
    std::thread t3(func);
 
    t1.join();
    t2.join();
    t3.join();
 
    cout << globNum << endl;
    return ;
}

3->

4->容器类

vector <int> test;
test.push_back();
test.push_back();
for(auto &e : test )
{
    cout << e <<endl;
}

5,memset,lambda

#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
 
struct table
{
    int age;
    char name[];
    int arr[];
};
 
int main()
{
 
    char buffer[]="hello";
    std::cout << "buffer is " << buffer <<std::endl;
 
    char buffer2[] = "dest";
    memcpy(buffer,buffer2,);
    std::cout << "after memcpy is " << buffer <<std::endl;
 
    memset(buffer,'*',strlen(buffer));
    std::cout << "after memset is " << buffer <<std::endl;
 
    int intBuffer[] ={,,,,};
    memset(intBuffer,,sizeof(int)*);
    for(const auto &n:intBuffer)
    {
        std::cout <<"memset int buffer" <<n << std::endl;
    }
 
    double doubleBuffer[]={1.0,2.0,3.0,4.0,5.0};
    memset(doubleBuffer,,sizeof(double)*); // set all double buffer inside is 0
    for(const auto&n: doubleBuffer)
    {
        std::cout << "double buffer is " << n <<std::endl;
    }
 
    int a =;
    int b =;
    std::swap(a,b);
    std::cout << "A:" <<a <<" B:" <<b <<std::endl;
 
    table ta;
    ta.age = ;
    strcpy(ta.name,"houdini");
    memset(ta.arr,,sizeof(int)*);
 
    table tb;
    tb.age = ;
    strcpy(tb.name,"maya");
    memset(tb.arr,,sizeof(int)*);
 
    std::cout << "ta " <<ta.age << " " << ta.name <<std::endl;
    std::cout << "tb " <<tb.age << " " << tb.name <<std::endl;
 
    std::cout << "swap struct \n";
    std::swap(ta,tb);
    std::cout << "ta " <<ta.age << " " << ta.name <<std::endl;
    std::cout << "tb " <<tb.age << " " << tb.name <<std::endl;
 
    // [] define the lambda , () is the arg
    // [captures] (params) -> ret {Statments;}
    std::cout << "\nlambda \n";
    auto func = []() { std::cout << "Hello world"; };
    func(); // now call the function
 
    std::vector<int> v;
    v.push_back();
    v.push_back();
    v.push_back();
    std::for_each(std::begin(v), std::end(v), [](int n) {std::cout << n << std::endl;});
 
    std::cout << "Make a lambda function \n";
    auto is_odd = [](int n) {return n+;};
    std::cout << is_odd() <<std::endl;
 
    std::function<int(int)> func2 = [](int i) { return i+; };
    std::cout << "func2: " << func2() << '\n';
 
    return ;
}

6，匿名指向函数指针:

int printadd(int x,int y)
{
    std::cout << "x  y :" << x << " | " << y<<std::endl;
    return x+y;
}
 
int main()
{
    typedef int (*callBack)(int x,int y);
    auto will_callBack = [](callBack callBackParm,int x,int y)
    {
        return callBackParm(x,y);
 
    };
    std::cout << will_callBack(printadd,,) <<std::endl;
 
   return ;
}

7,变长参数，C和C++

C:

int* AllocateArray(int count, ...)
{
    int *p = static_cast<int*> (malloc(sizeof(int)*count));
    va_list args;
    va_start(args, count);
    for (int i = ; i < count; ++i)
    {
 
        int arg = va_arg(args, int);
        *(p+i) = arg;
 
    }
    va_end(args);
    return p;
}
 
void DestroyArray(int *p)
{
    free(p);
}
 
int main()
{
 
    int *p = AllocateArray(,,,,,);
    auto lm = [](int *p,int size)
    {
        for(int i=;i<size;i++)
        {
            std::cout << p[i] <<std::endl;
        }
    };
 
    lm(p,);
    DestroyArray(p);
}

C++

#include <iostream>
using namespace std;
 
// end of call for 0 parameters
void show_list() {}
 
// we just transfer the ref
template <typename T>
void show_list(const T &value)
{
    cout << value <<" eof" << endl;
}
 
template <typename T ,typename... Args>
void show_list(const T &value ,const Args&... args)
{
    cout << value << ",";
    show_list(args...);
};
 
int main()
{
    show_list("",,,,);
    show_list("",,,,);
    return ;
}

8，模板函数.

基本概念:

(1):显式实例化(explicit instantiation)

template class ArrayTP<string,100> ;// generate ArrayTP<string,100> class

(2):显式具体化(explicit specialization)

template<> 
 
class ClassName<specialized-type-name>
 
{...}

(3):部分具体化(partial specialization)

template <class T1,class T2>
class Pair
{
    //...
};
 
template <class T1>
class Pair<T1,int>
{
    //...
};

当参数和模板都一致,类似以下形式:

1,

template <typename T>
inline T add(T x,T y)
{
    return x+y;
}
int main()
{
    std::cout << add(,) <<std::endl;
    std::cout << add(1.0f,2.0f) <<std::endl;
    //std::cout << add(1.0f,2) <<std::endl; //ERROR
    std::cout << add<int>(1.01,) <<std::endl;
    std::cout << add<double>(1.01,) <<std::endl;
    std::cout << add<float>(1.11f,) <<std::endl;
    return ;
}

2,显式模板定义，当返回值是模板，但是参数不是模板:

struct Data
{
    int val;
};
template <typename ValueType>
inline ValueType addOne(int val)
{
    std::cout << "go to addOne default template ";
    return ValueType(val) + ValueType();
}
 
template <>
inline float addOne<float>(int val)
{
    std::cout << "go to addOne <float> ";
    return float(val) + float();
}
template <>
inline Data addOne<Data> (int val)
{
    std::cout << "go to addOne <Data> struct";
    Data x;
    x.val = val + ;
    return x;
}
 
inline std::ostream &operator<<(std::ostream &os,Data rh)
{
    os << rh.val <<std::endl;
    return os;
}
 
int main()
{
    Data x = {};
    std::cout << addOne<int>() << std::endl; // default template
    std::cout << addOne<float>() <<std::endl;
    std::cout << addOne<Data>() <<std::endl;
 
    return ;
}

9,std::shared_ptr<> 智能指针.

#include <iostream>
#include <memory>
#include <string>
 
//template <typename Data>
class Test
{
public:
    Test():mName("NULL NAME")
    {
        std::cout <<"Create Test\n";
    }
    Test(std::string name)
    {
        mName = name;
    }
    void printName()
    {
        std::cout << "name is : " << mName <<std::endl;
    }
    void setName(std::string name)
    {
        mName = name;
    }
    ~Test(){
        std::cout <<mName<< " Test destroyed\n";
    }
    //using Ptr = std::shared_ptr<Test>;
    typedef std::shared_ptr<Test> Ptr;
private:
    std::string mName;
};
 
int main()
{
    std::cout << "Hello, World!" << std::endl;
    Test::Ptr test(new Test("Houdini"));
    test->printName();
    Test::Ptr test2 = test;
    test2->setName("maya");
    test2->printName();
    std::cout << test2.use_count() <<std::endl; //
    test2.reset();
    // test2 can't access
    std::cout << test.use_count() <<std::endl; //
    return ;
}

10,迭代器:

(1) 基于C++11 的forloop

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
void showValue(int x)
{
    cout << x <<endl;
}
 
template <typename iter,typename func>
func Navie_foreach(iter first,iter end,func f)
{
    for(;first!=end;++first)
    {
        f(*first);
    }
    return std::move(f);
};
 
int main()
{
    vector<int> list;
    list.push_back();
    list.push_back();
    list.push_back();
 
    cout << "use algorithm \n";
    for_each(list.begin(),list.end(),showValue);
 
    cout << "use my function \n";
    Navie_foreach(list.begin(),list.end(),showValue);
 
    cout << "use for(auto x: list)  \n";
    for(auto x: list)
    {
        showValue(x);
    }
 
    return ;
}

(2)自定义一个简单的CStringIter

class CStrIter
{
private:
    char **next;
public:
    CStrIter():next(){
    }
    CStrIter(char **text)
    {
        next = text;
    }
    const char* operator*()
    {
        return *next;
    }
    CStrIter &operator++() // for ++it
    {
        next = next+;
        return *this;
    }
    bool operator!=(void *data)
    {
        return *next != NULL;
    }
 
};
 
int main()
{
    char *menu[]= {"Houdini","Maya",NULL};
    CStrIter iter(menu);
    for(; iter!=NULL;++iter)
    {
        cout << *iter <<endl;
    }
 
}

(3)自定义一个简单的超尾迭代器

#include <iostream>
#include <iterator>
#include <vector>
#include <algorithm>
 
using namespace std;
 
template <typename T>
void dpelement(T i)
{
    cout << "->" << i <<endl;
}
template<>
void dpelement<int>(int i)
{
    cout << "int ->" << i <<endl;
}
void unit_test_foreach()
{
    const int size = ;
    int app[size]= {,,,};
    vector<int> dice(size);
    copy(app,app+size,dice.begin());
    for_each(dice.begin(),dice.end(),dpelement<int>);
}
 
template <typename T>
struct ourArray
{
 
public:
    class Iter
    {
    public:
        Iter():mHandle(),mArrayIndex(){
 
        }
        Iter(T *IterFirst):mHandle(IterFirst),mArrayIndex()
        {
 
        }
        Iter &operator=(T *data)
        {
            mHandle = data;
            return *this;
        }
 
        Iter& operator++() // for ++it
        {
            mHandle = mHandle+;
            mArrayIndex += ;
            return *this;
        }
        T &operator*()   // *it is our value
        {
            return *mHandle;
        }
        bool operator!=(T *data)
        {
            return mHandle != data ;
        }
        void next()
        {
            mHandle += ;
            mArrayIndex +=;
        }
        int index()const
        {
            return mArrayIndex;
        }
 
    private:
        T *mHandle;
        unsigned int mArrayIndex ;
    };
 
public:
    ourArray(int length)
    {
        mArray = new T[length +  ];
        for(int i=;i<length;i++)
        {
            mArray[i] = T(i+);
        }
        // define a eof signals
        mArray[length] = 0xFFFFFFFF;
        _size = length;
    }
    ~ourArray()
    {
        delete []mArray;
        mArray = nullptr;
    }
    void clear()
    {
        delete []mArray;
        mArray = nullptr;
    }
    T *begin()
    {
        return mArray;
    }
    T *end()
    {
        return mArray+(_size);
    }
    int operator[](int i)
    {
        return mArray[i];
    }
    unsigned int size()const
    {
        return _size;
    }
    const Iter ConstIter()
    {
        ourArray<T>::Iter iter;
        iter = array.begin();
        return iter;
    }
 
private:
    unsigned int _size;
    T *mArray;
};
 
int main()
{
    ourArray<float> array();
    ourArray<float>::Iter iter;
    for(iter=array.begin();iter!=array.end();++iter)
    {
        cout << " INDEX: " <<iter.index() << " Of value: " <<*iter <<endl;
 
    }
    cin.get();
    return ;
 
}

(4)

ostream_iterator,fill,copy

ostream_iterator <int,char> out_iter(cout,"\n");
 
    *out_iter++ = ; //same as cout<<15 << "\n"
    *out_iter = ;
 
    // STL copy vector to out_iter
    vector <int> data();
    fill(data.begin(),data.end(),);        // fill 1 to array
    copy(data.begin(),data.end(),out_iter); // print 1 six times
 
    cout << "\n";
    copy(data.begin(),data.end(),ostream_iterator<int,char>(cout,"->"));
    cout << "\n";

istream_iterator

int val = ;
    auto inputStr_iter = istream_iterator<int,char>(cin);
    val = *inputStr_iter;
    cout << "type value is " << val <<endl;

copy

template <typename T>
void dpelement(T i)
{
    cout << "->" << i <<endl;
}
template<>
void dpelement<int>(int i)
{
    cout << "int ->" << i <<endl;
}
 
string s1[] = {"good","wife","good","life"};
    vector<string> s1_t();
    copy(s1,s1+,s1_t.begin());
    for_each(s1_t.begin(),s1_t.end(),dpelement<string>);
 
const int size = ;
    int app[size]= {,,,};
    vector<int> dice(size);
    copy(app,app+size,dice.begin());
    for_each(dice.begin(),dice.end(),dpelement<int>);

list

#include <iostream>
#include <vector>
#include <algorithm>
#include <list>
using namespace std;
template <typename T>void showValue(T x)
{
    cout << x <<endl;
}
 
template <typename container,typename valueType>
void showContainerValue(const char*containerName, const container &con)
{
    cout <<"------"<< containerName <<"------\n";
    for_each(con.begin(),con.end(),showValue<valueType>);
    cout <<"------"<< containerName <<"------\n\n";
};
 
int main()
{
    list<int> one(,);
    showContainerValue<list<int>,int>("one",one);
 
    int stuff[] = {,,,,,,};
    list<int> two;
    two.insert(two.begin(),stuff,stuff+);
    showContainerValue<list<int>,int>("two",two);
 
    two.sort();
    showContainerValue<list<int>,int>("two after sort",two);
 
    two.unique();
    showContainerValue<list<int>,int>("two after unique",two);
 
    cin.get();
 
    return ;
}

set,set_union,set_difference,set_intersection (set里的元素不会重复，即使插入重复的。,set会自动排序，所以有可能顺序跟insert顺序不一样)

#include <set>
#include <iostream>
#include <algorithm>
#include <iterator>
using namespace std;
 
int main()
{
    int nq_array[] = {,,,,,};
    set<int> unique_mapsA(nq_array,nq_array+);
    set<int>::iterator start  = unique_mapsA.begin();
    unique_mapsA.insert();
    unique_mapsA.insert();
    unique_mapsA.insert();
 
    for(;start!=unique_mapsA.end();start++)
    {
        cout << *start <<endl;
    }
 
    set<int> unique_mapsB;
    unique_mapsB.insert();
    unique_mapsB.insert();
 
    set<int> unique_mapsC;
 
    // set_union()
    // set_difference()
    // set_intersection()
    set_intersection(unique_mapsA.begin(),unique_mapsA.end(),unique_mapsB.begin(),unique_mapsB.end(),
        insert_iterator<set<int>>(unique_mapsC,unique_mapsC.begin()));
 
    set<int>::iterator cIter;
    cout << "set_intersection\n";
    for(cIter=unique_mapsC.begin();cIter!= unique_mapsC.end(); cIter++)
    {
        cout << *cIter <<endl;
    }
    cin.get();
    return ;
 
}

set对ostream_iterator<int,char>out(cout,"\n")

cout << "ostream_iterator print set data\n";
    ostream_iterator<int,char> out(cout,"\n");
    copy(unique_mapsB.begin(),unique_mapsB.end(),out);

(5)multimap,pair (multimap的key 可以是重复的)

包括如何取出重复的键元素

#include <map>
#include <string>
#include <iostream>
using namespace std;
 
typedef multimap<int,string> mm;
typedef pair<int,string> mp;
 
template <typename T>
void printData(T &cont)
{
    auto iter = cont.begin();
    for(;iter!=cont.end();iter++)
    {
        cout << *iter <<endl;
    }
}
// specialize our multimap<int,string>
template <>
void printData<mm>(mm &cont)
{
    auto iter = cont.begin();
    for(;iter!=cont.end();iter++)
    {
        cout << "key:"<<(*iter).first << " -> value:"<<(*iter).second <<endl;
    }
}
 
int main()
{
    mm codes;
    mp item(,"maya");
    codes.insert(item);
    codes.insert(mp(,"houdini"));
    codes.insert(mp(,"json"));
    printData(codes);
 
    // isolate 213 data
    cout << "\nisolate 213 data\n";
    pair<mm::iterator,mm::iterator> range = codes.equal_range();
    for(mm::iterator it = range.first; it!=range.second; ++it)
    {
        cout << (*it).first << "->"<<(*it).second <<endl;
    }
    cin.get();
    return ;
 
}

9,函数对象

list,list->insert(),list.remove_if()

#include <iostream>
#include <list>
#include <algorithm>
#include <iterator>
 
template <typename T_C,typename valType>
void showArrayVals(T_C &cont,const char* contName)
{
    ostream_iterator<valType,char> out(cout,"\n");
    cout << "----------" << contName << "----------\n";
    for(auto iter = cont.begin();iter!=cont.end();iter++)
    {
        *out++ = *iter;
    }
    cout << "----------" << contName << "----------\n";
}
 
template <typename T>class TooBig
{
private:
    T cutoff;
public:
    TooBig(const T&cut):cutoff(cut){
 
    }
    bool operator()(const T& v){return v>cutoff;}
};
 
using namespace std;
 
int main()
{
    TooBig<int> b100();
    list<int> vals;
    vals.insert(vals.begin(),);
 
    list<int>::iterator it = vals.begin(); // first element
    ++it;
    vals.insert(it,);  // array [1,2]
    --it;
    vals.insert(it,,); // array [1,10,10,2]
    vals.insert(it,,);  // array [1,10,10,3,2]
    vals.insert(it,,);  // array [1,10,10,3,5,2]
    showArrayVals<list<int>,int>(vals,"vals container");
    vals.remove_if(b100);   // remove greater  9
    showArrayVals<list<int>,int>(vals,"after remove vals > 9 container");
 
    vals.remove_if(TooBig<int>());   // remove greater  4
    showArrayVals<list<int>,int>(vals,"after remove vals > 4 container");
 
    cin.get();
    return ;
}

10,STL string,map,set ,匿名函数

#include <iostream>
#include <string>
#include <cctype>
#include <iterator>
#include <algorithm>
#include <map>
#include <set>
using namespace std;
 
template <typename T>
void showMap(T &mm)
{
    T::const_iterator iter;
    for(iter=mm.begin();iter!=mm.end();iter++)
    {
        cout << "Key:"<<(*iter).first << " val:" << (*iter).second <<endl;
    }
}
 
char chToLower(char ch){
    return tolower(ch);
}
 
string &StrToLower(string &st)
{
    transform(st.begin(),st.end(),st.begin(),chToLower);
    return st;
}
 
// function convert map's value to a set,and convert to lower char
template <typename T1,typename T2>
void mapToSet(T1 &rhMap,T2 &rhSet)
{
    T1::const_iterator iter;
    for(iter=rhMap.begin();iter!=rhMap.end();iter++)
    {
        string item = (*iter).second;
        StrToLower(item);
        rhSet.insert(item);
    }
}
 
// show container's value
template<typename cont,typename valType>
void showContainerValues(cont &cc)
{
     //for_each(begin(cc), end(cc), [](valType n) {std::cout << n << std::endl;});
    for_each(cc.begin(),cc.end(),
        [](valType n) {std::cout << n << std::endl;}
    );
}
 
int main()
{
    map<int,string> ids;
    ids.insert(pair<int,string>(,"ADMIN"));
    ids.insert(pair<int,string>(,"ADMIN2"));  // do not accept repeat key
    ids.insert(pair<int,string>(,"SUPER"));
    ids.insert(pair<int,string>(,"HOUDINI"));
    ids.insert(pair<int,string>(,"NUKE"));
 
    ids[] = "MASTER"; // map can use [] anywhere
 
    showMap(ids);
 
    //
    cout << "\ninsert all map to set\n";
    set<string> wordset;
    mapToSet<>(ids,wordset);
    showContainerValues<set<string>,string>(wordset);
 
    cin.get();
    return ;
}

11