C++基础知识查漏补缺

std::cout << "hello world!" << std::endl;

// 等价于:
(std::cout << "hello world!") << std::endl;

int val = 0;

if (std::cin >> val) {
    std::cout << val << std::endl;      // 输入“整数”回车后会执行该语句
}
else {
    std::cerr << "error!" << std::endl; // 输入“字符串”回车后会执行该语句
}

// VS2015中
class A
{
private:
    double d = 12.34;
    int b = d;    // warning C4244: “初始化”: 从“double”转换到“int”，可能丢失数据
    int a{d};     // error C2397: 从“double”转换到“int”需要收缩转换
    int c = {d};  // error C2397: 从“double”转换到“int”需要收缩转换
};

int a = 0;
decltype((a)) b;  // error C2530: “b”: 必须初始化引用
decltype(a) c;


int m = 0;
int& n = m;
decltype(n) v;  // error C2530: “v”: 必须初始化引用

int arr[2][3] = {1,2,3,4,5,6};
printf("%p,%p,%p\n", arr, &arr, *arr); // 地址相同
printf("%d,%d,%d\n", sizeof(*arr), sizeof(*&arr), sizeof(**arr)); // 12,24,4

#include<iostream.h>
void main() 
{
    int n[][3]={10,20,30,40,50,60};
    int (*p)[3];
    p=n;
    cout<<p[0][0]<<","<<*(p[0]+1)<<","<<(*p)[2]<<endl;
}

// Allocate and zero-initialize array
void* calloc (size_t num, size_t size);

string s2 = "hello" + ", " + s1; /*  error:不能将字面值直接相加 */
等价于：string s2 = ("hello" + ", ") + s1;

string s3 = s1 + ", " + "world"; /* 正确 */
等价于： string s3 = (s1 + ", ") + "world";
等价于： string tmp = s1 + ", "; 
string s3 = tmp + "world";

std::string s = "abc";
const char* ch = s.c_str();
printf("%s\n", ch);  // abc
s = "123";
printf("%s\n", ch);  // 123

v1.assign(v2.begin() + v2.size() / 2, v2.end());

v1.clear();
copy(v2.begin() + v2.size() / 2, v2.end(), back_inserter(v1));

v1.insert(v1.end(), v2.begin() + v2.size() / 2, v2.end());

container::container(InputIterator begin, // 区间的起点
    InputIterator end); // 区间的终点

// 所有标准序列容器都提供这种形式的insert
void container::insert(iterator position, // 区间插入的位置
    InputIterator begin, // 插入区间的起点
    InputIterator end); // 插入区间的终点
// 关联容器使用它们的比较函数来决定元素要放在哪里，所以它们了省略position参数
void container::insert(lnputIterator begin, InputIterator end);

// 序列容器
iterator container::erase(iterator begin, iterator end);
// 关联容器
void container::erase(iterator begin, iterator end);

// 在大多数STL实现中，下面一段代码将会导致2~10次重新分配
vector<int> v;
for (int i = 0; i <= 1000; ++i) {
    v.push_back(i);
}

// 不会发生重新分配
vector<int> v;
v.reserve(1000);
for (int i = 0; i <= 1000; ++i) {
    v.push_back(i);
}

map<string, int> word_count;
for (const auto& kv : word_count) {
  // kv.first, kv.second
}

// C++17
for (const auto& [word, count] : word_count} {
}

for (const std::pair<const std::string, int>& kv : word_count) {
}

// 低效的写法：
for (const std::pair<std::string, int>& kv : word_count) {
}

#include <iostream>
#include <initializer_list>

void show(std::initializer_list<int> il)
{
    for (auto item : il) {
        std::cout << item << std::endl;
    }
}

int main()
{
    show({ 1,2,3,4,5,6 });
    return 0;
}

class A;

class B
{
private:
    static A a_;  // 正确：静态成员可以是不完全类型
};

std::array<int, 3> arr = {1, 2, 3};
std::array<int, 3> arr2 = arr;

std::vector<int> v1(10, 1);
std::vector<int> v2(15, 2);
swap(v1, v2);

class A
{
public:
    A(int x, const std::string& s)
        : x_(x), s_(s)
    {
    }

private:
    int x_;
    std::string s_;
};

int main()
{
    std::vector<A> v;
    v.push_back(A(1, "abc"));
    v.emplace_back(1, "abc");

    return 0;
}

std::vector<int> v;
std::cout << v[0];     // 运行时错误
std::cout << v.at(0);  // 抛出一个out_of_range异常

std::vector<int> v = {1, 2, 3};  // 1,2,3
v.resize(6);                     // 1,2,3,0,0,0
v.resize(1);                     // 1


std::vector<int> v = {1, 2, 3};  // 1,2,3; size = 3, capacity = 3
v.reserve(6);                    // 1,2,3; size = 3, capacity = 6
v.reserve(2);                    // 1,2,3; size = 3, capacity = 6

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>

// 将str中的strsrc替换成strdst
void StrReplace(std::string& str, const std::string& strsrc, const std::string& strdst)
{
    std::string::size_type pos = 0;
    auto srclen = strsrc.size();
    auto dstlen = strdst.size();

    while ((pos = str.find(strsrc, pos)) != std::string::npos)
    {
        str.replace(pos, srclen, strdst);
        pos += dstlen;
    }
}

int main()
{
    std::vector<int> vec = {1, 2, 3};
    // 对vec中的元素求和，和的初始值是0
    int sum = accumulate(vec.cbegin(), vec.cend(), 0);  // 6

    std::vector<std::string> svec = {"hello", "world"};
    // std::string str1 = accumulate(svec.cbegin(), svec.cend(), "$");  // 错误：const char*上没有定义+运算符
    std::string str2 = accumulate(svec.cbegin(), svec.cend(), std::string("$"));  // $helloworld

    std::string str3("hello world, hello cpp!");
    StrReplace(str3, "hello", "hi");

    return 0;
}

// 消除vector中的重复单词
void elimDups(vector<string>& words) 
{
    sort(words.begin(), words.end());
    
    // unique重排输入序列，使得不重复的元素出现在序列的开始部分，返回最后一个不重复元素之后的位置
    auto end_unique = unique(words.begin(), words.end());

    /* 
    标准库算法对迭代器而不是容器进行操作，算法不能（直接）添加或删除元素，
    可以使用vector的erase成员来完成真正的删除操作
    */
    words.erase(end_unique, words.end());
}

class A
{
public:
    A(int x) : x_(x) {}
    ~A() {}
    int x() const { return x_; }

private:
    int x_;
    std::string s_;
};

int main()
{
    std::unordered_set<A> us;  // error C2338: The C++ Standard doesn't provide a hash for this type.
    return 0;
}

class A
{
public:
    A(int x) : x_(x) {}
    ~A() {}
    int x() const { return x_; }

private:
    int x_;
    std::string s_;
};

size_t myHash(const A& a)
{
    return std::hash<int>()(a.x());
}

bool myEqu(const A& a1, const A& a2)
{
    return a1.x() == a2.x();
}

int main()
{
    std::unordered_set<A, decltype(myHash)*, decltype(myEqu)*> us(10, myHash, myEqu);  // 10: 桶的大小

    A a(123);
    us.insert(a);

    return 0;
}

std::map<int, int> mp;
mp[1] = 123;
mp[4] = 234;
mp[5] = 345;

auto it1 = mp.lower_bound(4);  // 返回一个迭代器, 指向第一个关键字不小于k的元素
auto it2 = mp.upper_bound(4);  // 返回一个迭代器, 指向第一个关键字大于k的元素

int k1 = it1->first;   // 4
int v1 = it1->second;  // 234

int k2 = it2->first;   // 5
int v2 = it2->second;  // 345

// 如果返回相同的迭代器，则给定的关键字不在容器中
if (mp.lower_bound(3) == mp.upper_bound(3))
{
    std::cout << "关键字" << 3 << "不在容器中！" << std::endl;
}

auto iter = mp.begin();
while (iter != mp.end()) {
    if (iter->second % 2 == 0) {
        mp.erase(iter++);
    }
    else {
        ++iter;
    }
}

class A
{
public:
    A() { std::cout << "A()" << std::endl; }
    ~A() { std::cout << "~A()" << std::endl; }
};

void myDeleter(A* pa)
{
    std::cout << "void myDeleter(A* pa)" << std::endl;
}

int main()
{
    {
        A a;
        std::shared_ptr<A> spa(&a, myDeleter);
    }
    {
        A a;
        std::unique_ptr<A, decltype(myDeleter)*> spa(&a, myDeleter);
    }
    return 0;
}

{
    std::unique_ptr<A> upa(new A);
    std::unique_ptr<A>(upa.release());
}

{
    std::unique_ptr<A> upa(new A);
    A* pa = upa.release();
    delete pa;
}

auto p = make_shared<int>(123);
weak_ptr<int> wp(p);  // wp弱共享p, p的引用计数未改变

// 若np不为空, 则条件成立
if(shared_ptr<int> np = wp.lock()) {
    cout << *np << endl;
}

struct Bad
{
    std::shared_ptr<Bad> getptr() {
        return std::shared_ptr<Bad>(this);
    }
    ~Bad() { std::cout << "Bad::~Bad() called\n"; }
};

struct Good : public std::enable_shared_from_this<Good> // note: public inheritance
{
    std::shared_ptr<Good> getptr() {
        return shared_from_this();
    }
};

int main()
{
    // Good: the two shared_ptr's share the same object
    std::shared_ptr<Good> gp1 = std::make_shared<Good>();
    std::shared_ptr<Good> gp2 = gp1->getptr();

    std::cout << "gp1.use_count() = " << gp1.use_count() << '\n';  // 2
    std::cout << "gp2.use_count() = " << gp2.use_count() << '\n';  // 2

    // Bad: shared_from_this is called without having std::shared_ptr owning the caller 
    try {
        Good not_so_good;
        std::shared_ptr<Good> gp1 = not_so_good.getptr();
    }
    catch (std::bad_weak_ptr& e) {
        std::cout << "exception: " << e.what() << '\n';
    }

    // Bad, each shared_ptr thinks it's the only owner of the object
    std::shared_ptr<Bad> bp1 = std::make_shared<Bad>();
    std::shared_ptr<Bad> bp2 = bp1->getptr();
    std::cout << "bp1.use_count() = " << bp1.use_count() << '\n';  // 1
    std::cout << "bp2.use_count() = " << bp2.use_count() << '\n';  // 1

    return 0;

    // undefined behavior: double-delete of Bad
}

// 错误示例1：

#include <memory>  
#include <iostream>  
using namespace std;
  
class A: public std::enable_shared_from_this<D>  
{  
public:  
    A()  
    {  
        cout<<"A::A()"<<endl;  
        std::shared_ptr<A> p = shared_from_this();  
    }      
};  
  
int main()  
{  
    std::shared_ptr<A> a = std::make_shared<A>();  
    return 0;      
}  

// 错误示例2：

#include <memory>
#include <iostream>  
using namespace std;  
  
class D: public std::enable_shared_from_this<D>  
{  
public:  
    D()  
    {  
        cout<<"D::D()"<<endl;  
    }  
      
    void func()  
    {  
        cout<<"D::func()"<<endl;  
        std::shared_ptr<D> p = shared_from_this();  
    }      
};  
  
int main()  
{  
    D d;  
    d.func();  
    return 0;      
}  

shared_ptr<T> p4 = p2; 
... 
p4 = p1; 

class A
{
public:
    A(const char* s, int x) : str_(new std::string(s)), x_(x) {}
    ~A() { delete str_; }

    A(const A& a) : str_(new std::string(*(a.str_))), x_(a.x_) { }

    A& operator=(const A& a)
    {
        auto news = new std::string(*(a.str_));
        delete str_;
        str_ = news;
        x_ = a.x_;
        return *this;
    }

private:
    std::string* str_;
    int x_;
};

int main()
{
    A a1("a1", 1);
    A a2("a2", 2);
    a2 = a1;

    return 0;
}

#include <utility>

int main()
{
    int a = 0;
    //int&& b = a;             // 错误：无法将左值绑定到右值引用
    int&& c = 0;               // 正确：字面常量是右值
    int&& d = std::move(a);    // 正确：显示地将一个左值转换为对于地右值引用类型

    return 0;
}

#include <iostream>
#include <string>
#include <cstring>

class ZString
{
public:
    ZString() : str_(new char[1]) {
        str_[0] = 0;
    }

    ZString(const char* s) {
        printf("ZString(const char* s)\n");
        int len = strlen(s) + 1;
        str_ = new char[len];
        strcpy_s(str_, len, s);
    }

    ZString(const ZString& s) {
        printf("ZString(const ZString& s)\n");
        int len = strlen(s.str_) + 1;
        str_ = new char[len];
        strcpy_s(str_, len, s.str_);
    }

    ZString& operator=(const ZString& s) {
        printf("ZString& operator=(const ZString& s)\n");
        if (str_ != s.str_)
        {
            delete[] str_;

            int len = strlen(s.str_) + 1;
            str_ = new char[len];
            strcpy_s(str_, len, s.str_);
        }
        return *this;
    }

    ZString(ZString&& s) : str_(s.str_) {
        printf("ZString(ZString&& s)\n");

        s.str_ = new char[1];
        s.str_[0] = 0;
    }

    ZString& operator=(ZString&& s) {
        printf("ZString& operator=(ZString&& s)\n");
        if (str_ != s.str_)
        {
            str_ = s.str_;
            s.str_ = new char[1];
            s.str_[0] = 0;
        }
        return *this;
    }

    ~ZString() {
        printf("~ZString()\n");
        delete[] str_;
    }

private:
    char* str_;
};

template <class T>
void Swap(T& a, T& b) {
    T tmp = a;
    a = b;
    b = tmp;
}

template <class T>
void MoveSwap(T& a, T& b) {
    T tmp = std::move(a);
    a = std::move(b);
    b = std::move(tmp);
}

int main()
{
    ZString s;

    // 如果没有定义移动赋值运算符, 则会调用拷贝赋值运算符, 产生深拷贝
    s = ZString("hello");
    
    ZString s1 = "s1", s2 = "s2";
    MoveSwap(s1, s2);

    return 0;
}

int main()
{
    std::string str1 = "hello";
    std::string str2 = "world";
    zswap(str1, str2);
    return 0;
}

void zswap(std::string& a, std::string&b)
{
    // a = "hello", b = "world"
    std::string tmp(std::move(a));
    // a = "", b = "world", tmp = "hello"
    a = std::move(b);
    // a = "world", b = "", tmp = "hello"
    b = std::move(tmp);
    // a = "world", b = "hello", tmp = ""
}

class A
{
public:
    A(int step) : step_(step), position_(0) { }
    ~A() { }

    // 前置++
    A& operator++()
    {
        position_ = position_ + step_;
        return *this;
    }

    // 前置--
    A& operator--()
    {
        position_ = position_ - step_;
        return *this;
    }

    // 后置++
    A operator++(int)
    {
        A a = *this;
        position_ = position_ + step_;
        return a;
    }

    // 后置--
    A operator--(int)
    {
        A a = *this;
        position_ = position_ - step_;
        return a;
    }

private:
    int position_;
    int step_;
};

int main()
{
    A a(5);
    A b = a;

    b = ++a;
    b = --a;

    b = a++;
    b = a--;

    return 0;
}

int add(int i, int j) { return i + j; }

auto mod = [](int i, int j) { return i % j; };

struct divide {
    int operator() (int i, int j) {
        return i / j;
    }
};

int main()
{
    std::map<std::string, int(*)(int, int)> ops;
    ops["+"] = add;

    // 但是不能将divide存入ops
    //ops["/"] = divide;

    std::map<std::string, std::function<int(int, int)>> newops;
    newops["+"] = add;
    newops["-"] = std::minus<int>();
    newops["%"] = mod;
    newops["*"] = [](int i, int j) { return i * j; };
    newops["/"] = divide();

    int ret1 = newops["+"](10, 5);
    int ret2 = newops["-"](10, 5);
    int ret3 = newops["*"](10, 5);
    int ret4 = newops["/"](10, 5);
    int ret5 = newops["%"](10, 5);

    return 0;
}

double chu(int a, int b) {
    return a / b;
}

void main() {
    int x = 100, y = 20;
    // 创建一个函数指针数组，每一个元素都是一个函数指针
    double (*p[4])(int a, int b) = {jia, jian, cheng, chu};
    for (int i=0; i<4; ++i) {
        printf("%0.1f\n", p[i](x, y));
    }
}

class A
{
public:
    A(int x) : x_(x)  {}
    virtual ~A() {}

    int x_;
};

class B : public A
{
public:
    B(int x, int y) : A(x), y_(y) {}
    ~B() {}

    int y_;
};

class A
{
public:
    A() {}
    virtual ~A() {}
    virtual void func() {
        std::cout << "A::func()" << std::endl;
    }
};

class B : public A
{
public:
    B(){}
    ~B() {}

    void func() override {
        std::cout << "B::func()" << std::endl;
    }
};

int main()
{
    B b;
    A* pBase = &b;
    // 强行调用基类中定义的函数版本而不管pBase的动态类型是什么
    pBase->A::func();

    return 0;
}

class A {};
class B {
    virtual void f() {}
};

int main()
{
    std::cout << sizeof(A) << std::endl;  // 1
    std::cout << sizeof(B) << std::endl;  // 4

    return 0;
}

template <unsigned N, unsigned M>
// 数组不能拷贝，将参数定义为数组的引用
int complare(const char (&p1)[N], const char (&p2)[M])
{
    return strcmp(p1, p2);
}

int main()
{
    int x = complare("hello", "world");
    return 0;
}

template <typename T>
inline T const& max(const T& a, const T& b) {
    return a < b ? b : a;
}

// 调用时在max前面加上'::', 以便确保被调用的是在全局命名空间中定义的max(), 而不是std::max()。
int maxVal = ::max(1, 2);

max(1, 2);    // ok
max(1, 2.2);  // error
max(static_cast<double>(1), 2.2); // ok
max<double>(1, 2.2); // ok

#include <vector>
#include <stdexcept>

template <typename T>
class Stack
{
private:
    std::vector<T> elems;

public:
    void push(const T&);
    void pop();
    T top() const;
    bool empty() const {
        return elems.empty();
    }
};


template <typename T>
void Stack<T>::push(const T& elem) {
    elems.push_back(elem);
}

template <typename T>
void Stack<T>::pop() {
    if (elems.empty()) {
        throw std::out_of_range("empty stack!");
    }
    elems.pop_back();
}

template <typename T>
T Stack<T>::top() const {
    if (elems.empty()) {
        throw std::out_of_range("empty stack!");
    }
    return elems.back();
}

// 使用
Stack<int> stack;
bool empty = stack.empty();

template<>
class Stack<std::string>
{
    // ...
};

template <typename T>
class Stack
{
private:
    std::vector<T> elems;
public:
    void push(const T&) {
        // ...
    }
};

// 特化
template<>
class Stack<std::string>
{
private:
    std::vector<std::string> elems;
public:
    void push(const std::string& elem);
};

void Stack<std::string>::push(const std::string& elem) {
    elems.push_back(elem);
}

template <typename T1, typename T2>
class MyClass
{

};

// 一下多种形式的偏特化都是合理的

// 偏特化： 两个template parameter相同
template <typename T>
class MyClass<T, T>
{

};

// 偏特化：第二个类型为int
template <typename T>
class MyClass<T, int>
{

};

// 偏特化：两个template parameter均为指针类型
template <typename T1, typename T2>
class MyClass<T1*, T2*>
{

};

#include <vector>
#include <stdexcept>
#include <deque>

template <typename T, typename CONT = std::vector<T> >
class Stack
{
private:
    CONT elems;

public:
    void push(const T&);
    void pop();
    T top() const;
    bool empty() const {
        return elems.empty();
    }
};

template <typename T, typename CONT>
void Stack<T, CONT>::push(const T& elem) {
    elems.push_back(elem);
}

template <typename T, typename CONT>
void Stack<T, CONT>::pop() {
    if (elems.empty()) {
        throw std::out_of_range("empty stack!");
    }
    elems.pop_back();
}

template <typename T, typename CONT>
T Stack<T, CONT>::top() const {
    if (elems.empty()) {
        throw std::out_of_range("empty stack!");
    }
    return elems.back();
}

// 使用
int main()
{
    Stack<int> stack1;
    bool empty = stack1.empty();

    Stack<double, std::vector<double> > stack2;
    empty = stack2.empty();

    Stack<std::string, std::deque<std::string> > stack3;
    empty = stack3.empty();

    return 0;
}

#include <iostream>
#include <tuple>
#include <string>
#include <vector>

int main()
{
    std::tuple<int, std::string, std::vector<double>> tp1(1, "a", {1.0, 2.0});

    int v1 = std::get<0>(tp1);
    std::string v2 = std::get<1>(tp1);
    std::vector<double> v3 = std::get<2>(tp1);

    typedef decltype(tp1) tp1Type;
    size_t sz = std::tuple_size<tp1Type>::value;  // 3

    return 0;
}

#include <bitset>

int main()
{
    // 0x123: 000100100011
    std::bitset<16> b1(0x123);  // {1,1,0,0,0,1,0,0,1,0,0,0,0,0,0,0}

    std::bitset<8> b2("110");   // {0,1,1,0,0,0,0,0}
    b2.flip();                  // {1,0,0,1,1,1,1,1}

    return 0;
}

#define go(x) system(#x)  // 传递的参数，x自动加上"", 让其变成一个字符串
例如：
int var = 100;   // 要求输出格式 "var = 100"
#define printNum(x) printf("%s = %d", #x, x)
printNum(var);  // var = 100

#define l(i) x##i

int l(1) = 1;
int l(2) = 2;
int l(3) = 3;
printf("x1 = %d\n", x1);  // x1 = 1
printf("x2 = %d\n", x2);  // x2 = 2
printf("x3 = %d\n", x3);  // x3 = 3

#ifdef __cplusplus
extern "C" {
#endif

// ...

#ifdef __cplusplus
}
#endif

#if __cplusplus < 201103L
    #error "should use C++11 implementation"
#endif

class Base { virtual void foo() {} };
class Derived : public Base {};

Base* ptr = new Derived;
Derived* dptr = dynamic_cast<Derived*>(ptr);
if (dptr != nullptr) {
    // 转换成功
} else {
    // 转换失败
}

class C {};
const C *a = new C;
C *b = const_cast<C *>(a);

// myprj/my_lambda.h

#pragma warning(push)
  #pragma warning(disable:4512)
  #pragma warning(disable:4180)
  #include <boost/lambda/lambda.hpp>
#pragma warning(pop)  // 恢复最初的警告级别

#include <iomanip>

std::ostringstream oss("");

oss.str("");
oss << std::setw(6) << std::setfill('*') << "[END]";
cout << oss.str() << endl;  // *[END]

oss.str("");
oss << std::setw(6) << std::setfill('*') << "[]";
cout << oss.str() << endl;  // ****[]

// Windows VS2015
#include <sys/stat.h>

off_t GetLocalFileSize(const std::string& filename)
{
    struct stat fileStateBuf;
    memset(&fileStateBuf, 0, sizeof(fileStateBuf));
    stat(filename.c_str(), &fileStateBuf);
    
    off_t st_size = fileStateBuf.st_size;
    std::cout << "filesize = " << st_size << std::endl;
    return st_size;
}

long a = 9.50413e+006;
std::cout << std::scientific << a << std::endl; // 9504130
std::cout << std::fixed << a << std::endl;      // 9504130

// 从左往右输出
// 输出: 0 0 0 0 1 0 1 1
int n = 11;  // 0000 1011
int y = 0x80;
for (int i = 0; i < 8; ++i) {
    int x = (n & y) == y ? 1 : 0;
    cout << x << " ";
    y >>= 1;
}

// 从右往左输出
// 输出: 1 1 0 1 0 0 0 0
int n = 0x0B;  // 0000 1011
for (int i = 0; i < 8; ++i) {
    cout << (n & 1) << " ";
    n >>= 1;
}

std::string s1 = std::string(1, 'a');  // "a"
std::string s2 = std::string(2, 'a');  // "aa"
std::string s3 = std::string(3, 'a');  // "aaa"

std::string str1("abcde");
std::string str2;

// 直接用另一个字符串赋值
str2.assign(str1); // "abcde"

// 用另一个字符串的一个子串赋值
str2.assign(str1, 1, 3); // "bcd"

// 用一个字符串的前一段子串赋值
str2.assign(str1, 2);  // "cde"

// 用几个相同的字符, 赋值
str2.assign(5, 'c');   // "ccccc"

/* getenv example: getting path */
#include <stdio.h>    /* printf */
#include <stdlib.h>   /* getenv */

int main ()
{
  char* pPath;
  pPath = getenv("PATH");
  if (pPath != NULL)
      printf("The current path is: %s",pPath);
  return 0;
}

/* memchr example */
#include <stdio.h>
#include <string.h>

int main ()
{
  char * pch;
  char str[] = "Example string";
  pch = (char*) memchr (str, 'p', strlen(str));
  if (pch!=NULL)
    printf ("'p' found at position %d.\n", pch-str+1);
  else
    printf ("'p' not found.\n");
  return 0;
}

/* 输出: 'p' found at position 5. */

std::string byteToHexStr(unsigned char byte_arr[], int arr_len)
{
    std::ostringstream oss("");

    for (int i = 0; i < arr_len; ++i)
    {
        int b = byte_arr[i];
        char str_b[8] = {0};
        sprintf_s(str_b, sizeof(str_b)-1, "%02x", b);
        oss << str_b;
    }
    
    return oss.str();
}

int _tmain(int argc, _TCHAR* argv[])
{
    unsigned char byte_arr[24] = {0x00,0x00, 0x01, 0x02, 0x12, 0x99};

    // ret = "000001021299000000000000000000000000000000000000"
    std::string ret = byteToHexStr(byte_arr, 24);

	return 0;
}

auto timeNow = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch());
unsigned short ms = timeNow.count() % 1000;

auto timeNow = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch());
auto ts = timeNow.count() / 1000;
auto tms = timeNow.count() % 1000;
char now[64];
struct tm* ttime = std::localtime(&ts);
strftime(now, 64, "%Y-%m-%d %H:%M:%S", ttime);
std::ostringstream oss("");
oss << now << "." << std::setw(3) << std::setfill('0') << tms;
processTimeNode.append_child(pugi::node_pcdata).set_value(oss.str().c_str());

std::ostringstream oss("");
oss << std::this_thread::get_id();
std::string threadId = oss.str();

#include <iostream>
#include <thread>

void thread_task()
{
    printf("hello thread!\n");
}

int main()
{
    std::thread t(thread_task);
    t.join();
    return 0;
}

#include <iostream>
#include <thread>
#include <utility>
#include <chrono>
#include <functional>
#include <atomic>

void f1(int n)
{
    printf("thread 1 executing...\n");
    for (int i = 0; i < 5; ++i) {
        printf("id = %d, n = %d, i = %d\n", std::this_thread::get_id(), n, i);
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

void f2(int& n)
{
    printf("thread 2 executing...\n");
    for (int i = 0; i < 5; ++i) {
        printf("id = %d, n = %d, i = %d\n", std::this_thread::get_id(), n, i);
        ++n;
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
}

int main()
{
    int n = 0; 
    std::thread t1;                  // t1 is not a thread
    std::thread t2(f1, n+1);         // pass by value
    std::thread t3(f2, std::ref(n)); // pass by reference
    std::thread t4(std::move(t3));   // t4 is now running, t3 is no longer a thread

    t2.join();
    t4.join();

    printf("final value of n is %d\n", n);

    return 0;
}

#include <iostream>
#include <thread>
#include <chrono>
 
void foo()
{
    std::this_thread::sleep_for(std::chrono::seconds(1));
}
 
int main()
{
    std::thread t;
    // std::boolalpha将bool解析成为单词true, false.
    std::cout << "before starting, joinable: " << std::boolalpha << t.joinable() << '\n';
              
    t = std::thread(foo);
    std::cout << "after starting, joinable: " << t.joinable() << '\n';
              
    t.join();
    std::cout << "after joining, joinable: " << t.joinable() << '\n';
}
// output
before starting, joinable: false
after starting, joinable: true
after joining, joinable: false

#include <iostream>
#include <thread>
#include <chrono>
#include <string>
#include <mutex>
#include <map>

std::map<std::string, std::string> g_pages;
std::mutex g_pages_mutex;

void save_page(const std::string& url)
{
    // simulate a long page fetch
    std::this_thread::sleep_for(std::chrono::seconds(2));
    std::string result = "fake content";

    std::lock_guard<std::mutex> guard(g_pages_mutex);
    g_pages[url] = result;
}

int main()
{
    std::thread t1(save_page, "http://foo");
    std::thread t2(save_page, "http://bar");

    t1.join();
    t2.join();

    // safe to access g_pages without lock now, as the threads are joined
    for (const auto& pair : g_pages) {
        std::cout << pair.first << " => " << pair.second << "\n";
    }
}
// output
http://bar => fake content
http://foo => fake content

#include <iostream>
#include <thread>
#include <string>
#include <mutex>
#include <condition_variable>

std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;

void worker_thread()
{
    // wait until main() sends data
    std::unique_lock<std::mutex> lk(m);
    cv.wait(lk, [] {return ready;});

    // after the wait, we own the lock.
    std::cout << "Worker thread is processing data...\n";
    data += "after processing";

    // send data back to main()
    processed = true;
    std::cout << "Worker thread signals data processing completed!\n";

    // Manual unlocking is done before notifying, to avoid waking up
    // the waiting thread only to block again (see notify_one for details)
    lk.unlock();
    cv.notify_one();
}

int main()
{
    std::thread worker(worker_thread);
    data = "Example data";
    // send data to the worker thread
    {
        std::lock_guard<std::mutex> lk(m);
        ready = true;
        std::cout << "main() signals data ready for processing.\n";
    }
    cv.notify_one();

    // waite for the worker
    {
        std::unique_lock<std::mutex> lk(m);
        cv.wait(lk, [] {return processed;});
    }

    std::cout << "Back in main(), data = " << data << "\n";

    worker.join();
    return 0;
}

// output
main() signals data ready for processing.
Worker thread is processing data...
Worker thread signals data processing completed!
Back in main(), data = Example dataafter processing

#include "stdafx.h"

#define LOG(...) { \
    fprintf(stderr, "[File: %s, Line: %d]:\t", __FILE__, __LINE__); \
    fprintf(stderr, __VA_ARGS__); \
    fprintf(stderr, "\n"); \
}

int _tmain(int argc, _TCHAR* argv[])
{
    int x = 123;
    LOG("x = %d", x);
	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#include <stdarg.h>
#include <string>

void logv(const char *file, int line, const char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    printf("file: %s \n line: %d \n ", file, line);

    enum {
        MAX_BUF_LLEN = 512,
    };
    char buf[MAX_BUF_LLEN];

    snprintf(buf, MAX_BUF_LLEN-1,  "[FILE: %s, LINE: %d]***", file, line);

    printf("1--> %s\n", buf);

    printf("len = %d\n", strlen(buf));

    vsprintf(buf + strlen(buf), fmt, ap);
    printf("2--> %s\n", buf);

    // vsprintf(buf + strlen(buf), "%s", MAX_BUF_LLEN - 1, "");

    vprintf(fmt, ap);
    va_end(ap);
}

#define dolog(fmt, args...) logv(__FILE__, __LINE__, fmt, ##args)

int main(int argc, char *argv[])
{
    dolog("argc=%d\n", argc);

    return 0;
}