C++学习笔记——面向对象高级开发

C++学习笔记——面向对象高级开发

P2 转换函数 conversion function

class Fraction{
public:
	// 转换函数，不需要写返回值类型，编译器自动补充；不一定是基本类型
	operator double() const{ 
		return (double)(m_numerator/m_denominator);
	}
private:
	int m_numerator;//分子
	int  m_denominator;//分母
};

Fraction f(3,5);
double d = 4+f; // 调用operator double()将f转为double

P3 non-explicit-one-argument constructor

class Fraction{
public:
	Fraction(int num,int den=1):m_numerator(num),m_denomiator(den){}//1
	operator double() const;//2
	explicit Fraction(int num,int den=1):m_numerator(num),m_denomiator(den){}//3；explicit避免隐式调用
	Fraction operator+(const Fraction& f){
		return ...;
	}
	
private:
	int m_numerator;//分子
	int  m_denominator;//分母
};

Fraction f(3,5);
Fraction d2 = f+4;;//如果只定义了1，则调用了non-explicit构造函数讲4转为Fraction，然后调用+；同时定义1、2时会有二义性，编译报错；同时定义2、3会报错，不会调用3

P4 pointer-like classes，行为像指针的类

• 智能指针

template<class T>
class share_ptr{
public:
	T& operator*()const{return *px;}
	T* operator->()const{return px;}
	shared_ptr(T* p):px(p){}//接收一个天然指针
private:
	T* px;
	long* pn;
};

struct Foo{
	...
	void method(void){...}
};

shared_ptr<Foo> sp(new Foo);
Foo f(*sp);//解参考
sp->method();//px->method(); ->有传递性

• 迭代器：定义了++、–、*、->、==、!=等操作符

P5 function-like classes，行为像函数，仿函数

• 仿函数：重载了操作符()的类

P6 namespace经验谈

• namespace：避免命名冲突

P7 class template，类模板

P8 function template，函数模板

P9 member template，成员模板

template<class T1,class T2>
struct pair{
	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){}
};

P10 specialization，特化

template <class K> 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;}
}

P11 partial specialization模板偏特化

• 个数上的偏

template<typename T,typename Alloc=...>
class vector{
...
};
//偏特化
template<typename Alloc=...>
class vector<bool,Alloc>{
...
};

• 范围上的偏

template<typename T>
class C{
...
};
// 范围限定到指针的偏特化
template<typename T>
class C<T*>{
...
};

P12 template template parameter，模板模板参数

template<typename T,
		template<typename T> class SmartPtr//模板模板参数
		>
class XCls{
private:
	SmartPtr<T> sp;//！！！
public:
	XCls():sp(new T){}
};
XCls<string,shared_ptr> p1;
XCls<double, unique_ptr> p2;//错误
XCls<int, week_ptr> p3;//错误
XCls<long, auto_ptr> p4;

P13 关于C++标准库

• 容器，迭代器，算法，仿函数

P14 三个主题

• 数量不定的模板参数

void print(){}

template<typename T,typename... Types>
void print(const T& firstArg, const Types&... args){
	cout<<firstArg<<endl;
	print(args...);
	//sizeof(args)是参数个数
}

• auto：编译器自动推断类型
• range-based for

vector<double> vec;
...
for(auto e:vec){
	cout<<e<<endl;
	e *= 4;//值传递，不改变原始数组
}

for (auto& e:vec){
	e *= 3;//引用传递，会改变原始数组
}

P15 引用

int x = 0;
int* p = &x;//指针
int& r = x;//引用

void func1(Cls* pobj);
void func2(Cls obj);
void func3(Cls& obj);

//以下两个函数不能共存，same signature；调用方法一样，如果能共存就不知道调用哪个函数
void func(const int  a);
void func(const int& a);

void func(const int a) const;//const是函数签名的一部分，与以上两个函数能共存

P16 复合&继承关系下的构造和析构

• 继承：构造由内到外，析构由外到内
• 组合+继承：先构造父类，再构造组合

P17关于vptr和vtbl，虚指针、虚表

• 有虚函数的类就会多一个虚函数指针
• 动态绑定，多态
• 三个条件：指针调用，向上转型，调用虚函数
  

P18 关于this

• this指向的是子类对象

P19 对象模型：关于动态绑定

P20 关于 new，delete

• new：先分配内存，再调用构造函数
• delete：先调用析构函数，再释放内存

P21 重载new，delete

//全局
inline void* operator new(size_t size);
inline void* operator new[](size_t size);
inline void* operator delete(size_t size);
inline void* operator delete[](size_t size);
//成员
class Foo{
public:
	void* operator new(size_t);
	void operator delete(void*,size_t);//size_t是可选的
};

P22 示例

P23重载new()，delete()示例

P24 basic_string试用new(extra)扩充申请量