c++学习笔记十六

c with classes


尽量以const enum inline 替换#define
示例代码：
#define ASPECT_RATIO 1.653 //不进入记号表(symbol table)
替换为
const AspectRatio 1.653 //进入记号表


定义常量字符串
const std::string authorName("retacn");




class专属常量
示例代码如下：
class GamePlayer{
private:
static const int NumTurns=5;
int scores[NumTurns];
...
};


the enum hack替换define
class GamePlayer{
enum{NumTurns=5};
int scores[NumTurns];
}
注：取一个const的地址是合法的，取一个enum的地址是不合法有
如果不想让别人获得一个pointer或reference指向你的某个整数常量,可以使用其约束


template inline替换宏定义(macros)
示例代码如下：
#define CALL_WITH_MAX(a,b) f((a)>(b)?(a):(b))
替换为：
template<typename T>
inline void callWithMax(const T& a,const T& b){
f(a>b?a:b);
}




#include #ifdef #ifndef 仍是控制编译的重要角色




const的使用


const修饰指针
示例代码如下：
char greeting[] ="hello world"
char* p =greeting; //non-const pointer,non-const data
const char* p=greeting; //non-const pointer,const data
char* const p =greeting; //const pointer,non-const data
const char* p const p =greeting; //const pointer,const data
注：如果出现在*的左边，表示物是常量
分为以下两种情况,可以位于类型的左边或是右边:
void f1(const Widget* pw);
void f2(Widget const * pw);
如果出现在*右边，表示指针自身是常量
如果两边都出现，表示两者都是常量




const 修饰迭代器
示例代码如下：
std::vector<int> vec;
...
const std::vector<int>::iterator iter=vec.begin();//迭代器不得指向不同的东西
*iter=10; //可以
++iter; //错误，iter是const
std:vector<int>::const_iterator cIter=vec.begin();//迭代器所指的东西不可变
*cIter=10; //错误 *cIter是const
++cIter; //可以



const修饰函数
//令函数返回一个常量数
class Rational{...};
const Rational operator* (const Rational& lhs,const Rattional& rhs);


const修饰成员函数
//使成员函数可以作用于一个const对象身上
示例代码如下；
class TestBlock{
public:
..
const char& operator[](std::size_t position) const{
return text[position]; //operator[]for const 对象
}
char& operator[](std::size_t position){
return text[position];//operator[]for non-const对象
}
}
//使用
TextBlock tb("hello");
std::cout<< tb[0];//调用non-const TextBlock::operator[]


const TextBlock ctb("world");
std::cout<<ctb[0]; //调用const TextBlock::operator[]


std::cout<<tb[0];//可以
tb[0]='x';//可以
std::cout<<ctb[0];//可以
ctb[0]='x';//错误，不能写一个const TextBlock




bitwise const
示例代码如下：
class CTextBlock{
public:
...
char& operator[](std::size_t position)const{
return pText[position];
}
private:
char* pText;
}
//使用
const CTextBlock cctb("hello");//声明一个常量对象
char* pc=&cctb[0]; //指向cctb的数据
*pc='j'; //cctb的内容修改为"jello"




logical constness
示例代码如下：
class CTextBlock{
public:
...
std::size_t length() const;
private:
char* pText;
mutable std::size_t textLength; //可以被修改，即使在成员函数内
mutable bool lengthIsValid;//同上
}
std:size_t CTextBlock::length() const{
if(!lengthIsValid){
textLength=std::strlen(pText);
lengthIsValid=true;
}
return textLength;
}


当用const和non-const成员函数有着实质等价的实现时，令non-const版本调用const版本可避免代码重复
示例代码如下:
class TextBlock{
public:
...
const char& operator[](std::size_t position)const{
...
return text[position];
}
char& operator[](){
//将op[]返回值的const转除为*this加上const调用const op[]
return const_cast<char&>(static_cast<const TextBlock>(*this)[position]);
}
};




对象使用前需要先行初始化
示例代码如下：
int x=0; //基本类型手工初始化
const char* text="A C-style string";//指针手工初始化


double d;
std::cin>>d; //以读取input stream 的方式进行初始化






构造函数将对象进行初始化
示例代码如下；
class PhoneNumber{...};
//address book entry
class ABEntry{
public:
ABEntry(const std::string& name,const std::string& address,const std::list<PhoneNumber>& phone);
private:
std::string theName;
std::string theAddress;
std::list<PhoneNumber> thePhones;
int numTimesConsulted;
};
//构造函数(成员初始列 member initialization list)对其对象进行初始化
ABEntry::ABEntry(const std::string& name,const std::string& address,const std::list<PhoneNumber>& phones)
:theName(name),theAddress(address),thePhone(phones),numTimeConsulted(0)
{}
//对其对象进行赋值
ABEntry::ABEntry(const std::string& name,const std::string& address,const std::list<PhoneNumber>& phones){
theName=name;
theAddress=address;
thePhones=phones;
numTimesConsulted=0;
}






不同编译单元内定义之non-local static对象的初始化
两个源码文件，每个文件内至少包含一个non-local static对象


static对象的生命周期，从构造出来直到程序结束为止.
函数内的static对象称为local static
其他（global对象、定义于namespace作用域内的对象、在class内、在file作用域内）对象称为non-local static


编译单元(translation unit) 指产出单一目标文件(single object file)的源码


示例代码如下：
//应用场景


//单一文件系统
class FileSystem{
public:
...
std::size_t numDisks() const; //成员函数
...
};
extern FileSystem tfs;//预备给客户使用


//客户用以处理文件系统内的目录
class Directory{
public:
Directory(params);
...
};
Directory::Directory(params){
...
std::size_t disks=tfs.numDisks();//使用文件系统对象
...
}


//创建一个Directory对象，用来处理临时文件
Directory tempDir(params);


//好的处理方式 看过design patterns的话，这就是单例模式的一个实现手法
//以函数调用(返回一个reference指向local static对象)替换"直接访问non-local static对象"
class FileSystem{...};
FileSystem& tfs(){
static FileSystem fs;
return fs;
}
class Directory{...};
Directory::Directory(params){
...
std::size_t disks=tfs().numDisks();
}
Directory& tempDir(){
static Directory td;
retrun td;
}