c++ primer note

#include <algorithm>
#include <numeric>

int sum = accumulate(vec.begin(), vec.end(), 0);
string sum = accumulate(vec.begin(), vec.end(), string(""));

fill(vec.begin(), vec.end(), 0);
fill_n(vec.begin(), size, 0);	// 不能对空容器写
auto ret = copy(vec1.begin(), vec1.end(), vec2.begin());	// 返回vec2递增后的迭代器
replace(vec.begin(), vec.end(), 0, 10);

sort(vec.begin(), vec.end());
auto ret = unique(vec.begin(), vec.end());	// 返回不重复元素后的第一个位置迭代器

[capture list](parammeter list) -> return type {function body}

[](const string& a, const string& b){return a.size() < b.size();}
[sz](const string& a){return a.size() < sz;}
[](const string& a){cout << a;}

auto f = [v1]() mutable {return ++v1;}

[](int i) -> int {if (i < 0) return -i; else return i;}

#include <functional>
using namespace std::palceholders;
bool check_size(const string& s, int sz){return s.size() >= sz;}
find_if(vec.begin(), vec.end(), bind(check_size, _1, sz));

copy(vec1.begin(), vec1.end(), back_inserter(vec2));

string line = "abc def ghi";
auto r = find(line.rbegin(), line.rend(), ' ');
for(auto it = r.base(); it != line.end(); it++)
    cout << *it;
// output: ghi

#include <memory>
shared_ptr<string> p;

shared_ptr<string> p = make_shared<string>(2, '9');
auto p = make_shared<string>(2, '9');

auto r = make_shared<int>(42);
r = q;	// 递增q引用计数，递减r引用计数

class StrBlob{
public:
    StrBlob();
private:
    shared_ptr<vector<string>> data;
};

int *p = new int(10);
const int *pc = new const int(10);
delete p;
delete pc;

shared_ptr<int> p1 = new int(10);	// wrong
shared_ptr<int> p2(new int(10));	// right

shared_ptr<int> clone(int p){
	return shared_ptr<int>(new int(p));
}

if (!p.unique())
	p.reset(new string(*p))	// 不唯一，分配新的拷贝
*p += newVal;	// 唯一，可以直接改变对象

unique_ptr<string> p2(p1.release());
p3.reset(p1.release());

unique_ptr<int> clone(int p){
	return unique_ptr<int>(new int(p));
}

auto p = make_shared<int>(10);
weak_ptr<int> wp(p);

if(shared_ptr<int> np = wp.lock()){
	// 当对象存在，lock返回true时，进入函数体
}

#include <memory>
allocator<string> alloc;
auto const p = alloc.allocate(n);	// 分配未初始化的内存
auto q = p;
alloc.construct(q++, "hi");
alloc.construct(q++, 10, 'c');		// 在内存上构造
while(q != p)
	alloc.destroy(--q);		// 释放构造的内存
alloc.deallocate(p,n);			// 释放原始内存

auto p = alloc.allocate(v.size(), 2);
auto q = uninitialized(v.begin(), v.end(), p);	// 将v中元素拷贝至p
uninitialized_fill_n(q, v.size(), 10);		// 将q中元素赋值10

class Foo{
public:
	Foo();
	Foo(const Foo&);
}

Foo& operator=(const Foo& a1){
	...
	return *this;
}

class Foo{
public:
	~Foo();
}

class Foo{
public:
	Foo(const Foo&) = delete; // 阻止拷贝
}

class A{
public:
    A& operator=(const A& rhs){
        auto newp = new string(*rhs.ps);
        delete ps;
        ps = newp;
        i = rhs.i;
        return *this;
    }
private:
    string *ps;
    int i;
};

class A{
public:
    A& operator=(const A& rhs){
        ps = rhs.ps;
        i = rhs.i;
        return *this;
    }
private:
    shared_ptr<string> ps;
    int i;
};

int i = 10;
int &r1 = i;
int &&r2 = i*10;
const int &r3 = i*10;
int &&r4 = r2;	// 错误，r2是左值

#include <utility>
int &&r5 = std::move(r1);

A(A &&s) noexcept	// 必须承诺函数不抛出异常，否则编译器还是会调用拷贝构造函数
: element(s.element) {
	s.element = nullptr;
}

vector<string> v(make_move_iterator(s.begin()), make_move_iterator(s.end()));

auto n = (s1+s2).find('a');	// 在右值上调用成员函数

Foo& operator=(const Foo&) &;	// 只能用于左值

data1 + data2;
operator+(data1, data2);

data1 += data2;
data1.operator+=(data2);

ostream& operator<<(ostream& os, const A& item){
	os << item.f();
	return os;
}

istream& operator>>(istream& is, A& item){
	is >> item.elements;
	if(is)			// 检查输入是否成功
		...
	else
		item = A();	// 输入失败，对象赋予成默认状态
	return is;
}

A operator+(const A& lhs, const A& rhs){
	A sum = lhs;
	sum += rhs;
	return sum;
}

vector<string> v = {'a', 'b', 'c'};

A& operator=(initializer_list<string> li){
	auto data = alloc_n_copy(li.begin(), li.end());
	free();					// 释放当前内存空间
	elements = data.first;	// 更新数据成员，指向新空间
	return *this;
}

class A{
public:
	string& operator[](int n) {return elements[n];}
	const string& operator[](int n) const {return elements[n];}
private:
	string *elements;
}

A& operator++(){
	check();	// 检查在容器中的位置
	++curr;
	return *this;
}

A& operator++(int){ // int形参起标志作用，不会用到
	A ret = *this;
	++*this;
	return ret;
}

p.operator++(0);	// 后置版本
p.operator++();		// 前置版本

string& operator*() const{
	auto p = check();
	return (*p)[curr];
}

string* operator->() const{
	return & this->operator*();	// 返回*运算符的地址
}

int operator()(int val) const{
	return val;
}

sort(vec.begin(), vec.end(), greater<int>();)

#include <functional>
int add(int i, int j) {return i+j;}
auto mod = [](int i, int j) {return i%j};
stuct divide{
	int operator()(int i, int j) {return i/j;}
}

function<int(int, int)> f1 = add;		// 函数指针
function<int(int, int)> f2 = divide();	// 函数对象
function<int(int, int)> f3 = [](int i, int j) {return i%j};	// lambda
cout << f1(2,4);

map<string, function<int, int>> binops = {
	{"+", add},
	{"/", divide()},
	{"%", [](int i, int j) {return i%j}},
}
binops["+"](2,4);
binops["/"](2,4);
binops["%"](2,4);

operator type() const;

class SmallInt{
public:
	SmallInt(int i = 0): val(i)			// int -> SmallInt
	operator int() const {return val;}	// SmallInt -> int
private:
	int val;
}

class SmallInt{
public:
	explicit operator int() const {return val;}
}

SmallInt si = 3;
si + 3;						// wrong
static_cast<int>(si) + 3;	// right

class B: public A{
    ...
}

B b;
A *p = &b;  // 派生类到基类的隐式转换

A: virtual void f1(int) const;
B: void f1(int) const override;

int i = p->f();
int i = p->A::f();

class A{
public:
	f() = 0;
}

class Base{
protected:
    int mem;
}
class Derive:public Base{
    friend void f1(Derive& d) {d.mem;}      // right
    friend void f2(Base& b) {b.mem;}        // wrong
}

class Base{
public:
    int size;
}
class Derive: private Base{
public:
    using Base::size;   // 由于private继承，size默认是Derived私有成员，using将其声明为公有
}

class Base{
public:
    virtual ~Base() = default;
}

class Derive: public Base{
public:
    using Base::Base();	// 继承基类的构造函数
}

vector<shared_ptr<Base>> vec;
vec.push_back(make_shared<Base>(...));
vec.push_back(make_shared<Derive>(...));

template <typename T>
int compare(const T& v1, const T& v2){
	if(less<T>()(v1, v2)) return -1;
	...
}

template <unsigned N, unsigned M>
int compare(const char (&p1)[N], const char (&p2)[M]){
	...;
}

template <typename T> A<T> A<T>::f(){	// 作用域外 A<T>
	A ret = *this;			// 作用域内 A
}

template<typename T> class A;
template<typename T> class C{
	// 引用特定实例，须先声明
	friend class A<T>;
	// 引用所有实例，无须先声明
	template<typename X> friend class B;
}

template <typename T> using twin = pair<T, T>
twin<string> sth;		//twin<string> <==> pair<string, string>

template <typename T> class A{
public:
	static count() {return cnt;}
	...
}

A<int> a;
ct = a.count();
auto ct = A<int>::count();	// 加上<int>

template <typename T> typename T::value_type count() {}

template <typename T, typename F = less<T>>
int compare(const T& v1, const T& v2, F f = F()){
	if(f(v1, v2)) return -1;
	...
}

template<class T = int> class A{
	...
}

template <typename T> class A{
	// 声明
	template <typename IT>  A();
}

// 定义
template <typename T> template <typename IT>
A<T>::A() { }

external template class A<int>;			// 声明
template int compare(const int&, const int&);	// 定义

template<typename T1, typename T2, typename T3> T3 sum(T2, T1) ;
auto val = sum<long long, int, long>(i, j);

template<typename IT>
auto f(IT beg, IT end) -> decltype(*beg){
	return *beg;
}

remove_reference<decltype(*sth)>::type // => sth的类型
remove_pointer...
remove_extent...

template<typename T> int compare(const T&, const T&);
int (*p)(const int&, const int&) = compare;

template <typename T, typename... Args>
void foo(const T& t, const Args& ... rest);
// Args模板参数包， rest函数参数包

template <typename... Args> void g(Args ... args){
	cout << sizeof...(Args);	// 类型参数数目
	cout << sizeof...(args);	// 函数参数数目
}

template<typename T> ostream &print(ostream& os, const T& t){
	return os << t;
}
template<typename T, typename... Args> 
ostream &print(ostream& os, const T& t, const Args&... rest){
	return print(os, rest...);
}

template<typename T, typename... Args> 
ostream &print(ostream& os, const T& t, const Args&... rest){	// 扩展Args
	return print(os, rest...);				// 扩展rest
}

template<typename T, typename... Args> 
ostream &print(ostream& os, const T& t, const Args&... rest){
	return print(os, A(rest)...);				// 对每一项调用A()，然后打印
}

template<typename T> int compare(const T&, const T&);
template<> int compare(const char* const &p1, const char* const &p2){
	return strcmp(p1, p2);		// 特例化 T => const char*
}

tuple<int, vector<string>> t(12, {"abc"});
auto item = make_tuple(...);
auto sth = get<0>(item);

#include <bitset>
bitset<32> b(0U);
bitset<32> b("1100");
unsigned long out = b.to_ulong();

default_random_engine e;
default_random_engine e(seed);
cout << e();

uniform_int_distribution<unsigned> u(0, 9);
cout << u(e);

static default_random_engine e;
static uniform_int_distribution<unsigned> u(0, 9);
cout << u(e);

void f() noexcept;

void f() noexcept(true);	// 不会抛出异常
void f() noexcept(false);	// 可能抛出异常

namespace A{
	....
}

class Derive: public Base1, public Base2{}

struct D: public B1, public B2{
	using B1::B1;
	using B2::B2;
	D(): B1(s), B2(s) {}	// 基类构造函数出现冲突，需要自定义
}

// 标准库的定义
void* operator new(size_t);
void* operator new(size_t, nothrow_t&) noexcept;
void* operator new(size_t, void*); 		// 该版本仅供系统使用，不能被重载

// 使用
int *p = new int;
int *p = new (nothrow) int;	// new的定位式，使用额外形参

#include <cstdlib>
void* operator new(size_t size){
    if (void* mem = malloc(size))
        return mem;
    else
        throw bad_alloc();
}

void operator delete(void* mem) noexcept {free(mem);}

new (place_address) type
new (place_address) type (initializers)
new (place_address) type [size]
new (place_address) type [size] { braced initializer list }

string *p = new string("..");
p->~string();			// 销毁对象却不释放内存

dynamic_cast<type*>(e);
dynamic_cast<type&>(e);
dynamic_cast<type&&>(e);

if(Derive *dp = dynamic_cast<Derive*>(bp))
	// 使用dp指向的Derive对象
else
	// 使用bp指向的Base对象

#include <typeinfo>
void f(const Base& b){
	try{
		const Derive& d = dynamic_cast<Derive&>(b);
		// 使用b引用的Derive对象
	} catch (bad_cast){
		// 处理失败情况
	}
}

Derive *dp = new Derive;
Base *bp = dp;
typeid(*dp) == typeid(*bp) == typeid(Derive)
typeid(bp) == type(Base*)

class Base{
	friend bool operator==(const Base&, const Base&);
protected:
	virtual bool equal(const Base&) const;
}

class Derive: public Base{
protected:
	virtual bool equal(const Base&) const{
		auto r = dynamic_cast<const Derive&>(rhs);
	}
}

bool operator==(const Base& lhs, const Base& rhs){
	return typeid(lhs) == typeid(rhs) && lhs.equal(rhs);
}

enum class pepper{red, yellow, green};	// 限定作用域
enum color{red, yellow, green};		// 不限定作用域类型
enum {a=1, b=3, c=10};

color hair = red;
color hair = color::red;
pepper p = pepper::green;

class Screen{
public:
	typedef std::string::size_type pos;
	char get_cursor() const { return contents[cursor]; }
	char get() const;
	char get(pos ht, pos wd) const;
	static const std::string Screen::*data() { return &Screen::contents; }
private:
	std::string contents;
	pos cursor;
	pos height, width;
}

const string Screen::*pdata = &Screen::contents;	// pdata并非指向实际数据
const string Screen::*pdata = Screen::data();

Screen myScreen;
auto s = myScreen.*pdata;	// 指向实际数据

auto pmf = &Screen::get_cursor;
char (Screen::*pmf2)(Screen::pos, Screen::pos) const = &Screen::get;

char c = (myScreen->*pmf)();
char c2 = (myScreen->*pmf2)(0, 0);

using Action = char (Screen::*)(Screen::pos, Screen::pos) const;
Action get = &Screen::get;

class Screen{
public:
	Screen& up();
	Screen& down();
	using Action = Screen& (Screen::*)();
	enum Directions { UP, DOWN };
	Screen& move(Direction cm){
		return (this->*Menu[cm])();
	}
private:
	static Action Menu[];
}
Screen::Action  Screen::Menu[] = {&Screen::up, Screen::down};

myScreen.move(Screen::UP);

function<bool (const string&)> fcn = &string::empty;
find_if(v.begin(), v.end(), fcn);

find_if(v.begin(), v.end(), mem_fn( &string::empty));

auto f = mem_fn( &string::empty);
f(&v[0]);		// 传入引用，使用->*调用函数 
f(*v.begin());		// 传入对象，使用.*调用函数 

find_if(v.begin(), v.end(), bind( &string::empty, _1));

auto f = bind( &string::empty, _1);
f(&v[0]);		// 传入引用，使用->*调用函数 
f(*v.begin());		// 传入对象，使用.*调用函数 

typedef unsigned int Bit;
class File{
	Bit mode: 2;
	Bit modified: 1;
}

volatile int a;

extern "C" void f();
extern "C"{
	void g();
	void (*pf)(int);	// C指针与C++不同
}