C++面向对象学习笔记(下)

class Fraction {
public:
// 要加const，分子和分母并不会改变
// 由于已经有了double(),虽然是返回double类型，但是可以不写
    operator double() const {
        return (double)(m_numerator/m_denominator);
    }
private:
    int m_numerator; // 分子
    int m_denominator; // 分母
}
Fraction f(3,5);
double d = 4 + f;

public:
// 1个实参 
    Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) {}
    Fraction operator + (const Fraction& f) {
        return Fraction(...);
    }
Fraction f(3,5);
Fraction d2 = f + 4; // 调用non-explicit ctor将4chang Fraction(4,1),然后调用operator +

pair<Derived1, Derived2> p;
pair<Base1, Base2> p2(p);
// 上面相当于=>下式
// 把一个由鲫鱼和麻雀构成的pair,放进一个由鱼类和鸟类构成的pair
pair<Base1, Base2> p2(pair<Derived1, Derived2>());

template <class Key>
struct hash {};

template<>
struct hash<char> {
    size_t operator () (char x) const { return x; }
};

template<>
struct hash<int> {
    size_t operator () (int x) const { return x; }
};

template<>
struct hash<long> {
    size_t operator () (long x) const { return x; }
};

cout << hash<long>()(1000);

template <typename T, typename Alloc=...>
class Vector { ... };

template <typename Alloc=...> // T已绑定
class Vector<bool, Alloc> {};

template <typename T>
class C { ... };

template <typename U>
class C<U*> { ... }; // 变成了指针

// 对应上面两个模板
C<string> obj1;
C<string *> obj2;

template <typename T,
        template <typename T>
            class Container
        >
class XCLs {
private:
    Container<T> c;
public:
    ...
}

template <typename T>
using Lst = list<T, allocator<T>>;
XCLs<string, list> mylst1; // ERROR，容器是有第二模板参数的，有的有第三。。。
XCLs<string, Lst> mylst2; // RIGHT

template <class T, class Sequence = deque<T>>
class Stack {
protected:
    Sequence c; // 底层容器
}
Stack<int> s1; // 有默认参数
Stack<int, list<int>> s2; // 已经绑定死了，没有模糊的东西

void print() {}

template <typename T, typename... Types>
void print(const T& firstArg, const Types&... args) {
    cout << firstArg << endl;
    print(args...); // 递归调用，最后一次没有参数，调用上面的print()
}

print(7.5, "hello", bitset<16>(377), 41);
// sizeof...(args)返回参数个数

list<string> c;
...
// 以前这种写法
list<string>::iterator ite;
ite = find(c.begin(), c.end(), target);
// 等价于下面
auto ite = find(c.begin(), c.end(), target);
// 但是下面这种写法是错误的
auto ite;
ite = find(c.begin(), c.end(), target);

vector<double> vec;
...
for (auto elem : vec) {
    cout << elem << endl; // 不会改变vector里的内容
}
for (auto& elem : vec) {
    cout << elem *= 3; // 会改变vectoe里的内容
}

// 两者不能同时存在，由于是same signature(不包含返回类型)
double imag(const double& im) { ... }
double imag(const double im) { ... } // 会有二义

const String str("hello world");
str.print(); // 设计print()的时候是必须加上const的

charT operator[] (size_type pos) const {
    ...... // 不必考虑COW
}

reference operator[] (size_type pos) {
    ...... // 必须考虑COW
}
COW: Copy On Write

Foo* pf = new (300, 'c')Foo;

// 一般的operator new()重载
void* operator new(size_t size) {
    return malloc(size);
}
// 标准库提供的重载,只传回来pointer
void* operator new(size_t size, void* start) {
    return start;