「笔记」C++面向对象高级开发(下)

conversion function & non-explicit-one-argument ctor

  • conversion function 将该类型转换为其他类型
  • non-explicit-one-argument ctor 将其他类型的对象转换为该类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
class Fraction{
public:
Fraction(int num, int den = 1)
: m_numerator(num), m_denominnator(den){ }
operator double() const {
return (double)((double)m_numerator / (double)m_denominnator);
}
Fraction operator+(const Fraction& f){
return Fraction(...);
}
private:
int m_numerator;
int m_denminator;
};
Fraction f(3,5);
Fraction d2 = f+4; //[Error] ambiguous

pointer-like classes & function-like classes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template<class T>
class shared_ptr{
public:
T& operator*() const{ return *px; }
T* operator->() const{ return px; }
shared_ptr(T* p) : px(p){ }
private:
T* px;
...
}

shared_ptr<Foo> sp(new Foo);
Foo f(*sp);
sp->method(); // = px->method() '->'运算符传递性
1
2
3
4
template <class T>
strict minus{
T operator()(const T& x,const T& y) const { return x - y; }
}

member template

需要用多个派生类来构造多个基类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template <class T1,class T2>
struct pair{
typedef T1 first_type;
typedef T2 second_type;

T1 first;
T2 second;

pair() : first(T1()),second(T2()) { }
pair(const T1& a,const T2& b) : first(a), second(b) { }

template <class U1, class U2>
pair(const pair<U1, U2>& p) : first(p.first), second(p.second) { }
}

template specialization & partial specialization

1
2
3
template <class Key> struct hash { }
template <char> struct hash { ... };;
template <int> struct hash { ... };

编译器会先找特化模板,未找到会使用泛化模板。(类似“重载”模板)

1
2
3
4
5
6
template<typename T, typename Alloc=...>
class vector{...}

template<typename Alloc=...>
class vector<bool, Alloc>{...} // 个数偏特化
// 个数偏特化,只能从左往右进行偏特化
1
2
3
4
5
template <typename T>
class C{ ... };

template <typename T>
class C<T*>{ ... }; // 范围偏特化

本文标题:「笔记」C++面向对象高级开发(下)

文章作者:赵砚潇

发布时间:2021年01月24日 - 23:01

最后更新:2021年01月25日 - 00:01

原始链接:https://blog.zyx.sh/2021/01/24/cpp_houjie2/

许可协议: 署名-非商业性使用-相同方式分享 4.0 国际 转载请保留原文链接及作者。

Donate comment here