• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

c++:const、初始化、copy构造/析构/赋值函数

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

 

构造函数

Default构造函数:可被调用而不带任何实参的构造函数,没有参数或每个参数都有缺省值。如:

class A {
public:
    A();
};

将构造函数声明为explicit,可阻止它们被用来执行隐式类型转换,但仍可用来进行显示类型转换。如:

class B {
public:
    explicit B(int x = 0, bool b = ture);
};

copy构造函数:用于以同型对象初始化自我对象,以passed by value的方式传递对象;·

copy assignment操作符:用于从另一个同型对象中拷贝其值到自我对象。如:

class Widget {
  public:
      Widget();
      Widget(const Widget& rhs); //copy构造函数
      Widget& operator=(contst Widget& rhs);//copy assignment操作符
};
Widget w2(w1); //调用copy构造函数
w1 = w2; //没有新对象被定义 调用copy assignment(copy赋值)操作
Widget w3 = w2; //有新对象被定义 调用copy构造函数

 

其它笔记

TR1:Technical Rpeort1,描述加入C++标注你程序库的诸多新机能的规范,机能以新的class templates和function templates形式体现,TR1组件置于命名空间std内嵌套的命名空间tr1中;

 Boost:组织/网站,提供可移植的开源C++程序库,大多数TR1机能以Boost为基础。

 

C++可主要分为4个sublanguage部分:

 1. C,以C为基础,包含blocks, statements, preprocessor, built-in data types, arrays, pointers等内容。

 2. Object-oriented C++,包含C with classes的面向对象诉求,如classes(构造函数和析构函数), encapsulation, inheritance, polymorphism(多态), virtual函数(动态绑定)等。

 3. Template C++,包含泛型编程(generic programming)部分。

 4. STL,template程序库,包含containers, iterators, algorithms, function objects等内容。

 C++高效编程守则的变化取决于使用的是C++的哪一部分。

 

注意:尽量以const, enum, inline替换#define,降低对预处理器的需求

如:以const常量替换#define

/*#define不被视为语言的一部分,记号名称ASPECT_RATIO可能没进入记号表(symbol table)内;*/
#define ASPECT_RATIO 1.653; //错误

/*语言常量Aspect肯定会被编译器看到,进入记号表内:*/
const double AspectRatio = 1.653; //正确

定义常量指针时,因为常量定义是通常被放在头文件内,有必要将指针声明为const:

const char* const authorName = “Scott Meyers”;

另:string对象通常比char*-based更合适:

const std::string authorName(“Scott Meyers“); 

 

用static const定义class专属常量 

定义class专属常量时,为确保此常量至多只有一份实体,将其作为static成员:

class GamePlayer {
  private:
      static const int NumTurns = 5;//常量声明式
      int scores[NumTurns];//使用常量
};

 如果需要取class专属常量的地址,需要为编译器提供class专属常量的定义式;

定义式需放入实现文件,而非头文件;

class常量在声明时获得初值,定义时不可再设初值:

cons tint GamePlayer::NumTurns;//常量定义式

如果使用旧式编译器,则不允许static成员在声明时获得初值,另in-class初值设定也只允许对整数常量进行,可采用: 

class CostEstimate {
  private:
      static const double FudgeFactor;
};
//常量定义位于实现文件内,赋初值
const double ConstEstimate::FudgeFactor = 1.35;

 

若编译器不允许in class初值设定,用enum hack补偿

Enum hack:类似#define,取#define和enum地址不合法,而取const地址合法;

Enum和#define不会导致非必要的内存分配;

可约束使别人无法获得指向某个指针常量的指针或引用;

如果编译器错误地不允许in class初值设定,可改用enum hack补偿做法,使该常量成为一个记号名称:

class GamePlayer {
  private:
      enum {NumTurns = 5};
      int socres[NumTurns];
};

 

使用template inline函数替代宏:

template<typename T>
inline void callWithMax(const T& a, const T& b) {
    f(a>b?a:b);
}

 

尽可能使用const

用const来修饰指针,可以指出指针自身和其所指物是否为const。

如果关键词const出现在星号左边,表示被指物是常量;如果出现在星号右边,表示指针自身是常量;如果出现在星号两遍,表示被指物和指针两者都是常量:

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* const p = greeting;//const pointer, const data

如果被指物是常量,关键词const写在类型或写在类型时候星号之前的意义都相同:

void f1(const Widget* pw);
void f2(Widget const * pw);//两种都表示获得一个指针,指向常量Widget对象

STL中迭代器的作用相当于T*指针,声明迭代器为const相当于声明一个T* const指针,表示该迭代器不得指向不同的东西,但所指东西的值可以改动:

const std::vector<int>::iterator iter = vec.begin();//声明迭代器为const
*iter=10; //可行

如果希望迭代器所指东西不可改动,即模拟const T*指针,则声明const_iterator:

std::vector<int>::const_iterator cIter = vec.begin();
*iter=10;//不可行

 

确定对象被使用前已经被初始化

C++规定对象的成员变量初始化动作发生在进入构造函数本体之前。如果按照以下操作,只是在构造函数体内赋值,而不是初始化:

ABEntry::ABEntry(const std::string& name, const std::string& address,
                 const std::list<PhoneNumber>& phones) {
    theName = name;
    theAddress = address;//赋值(assignments)
    thePhones = phones;  //而不是初始化(initializations) 
    numTimesConsulted = 0;
}

完成初始化更好的做法是使用成员初值列(member initialization list:

ABEntry::(const std::string& name, const std::string& address,
          const std::list<PhoneNumber>& phones)
    :theName(name),
    :theAddress(address),
    :thePhones(phones),
    :numTimesConsulted(0) {}

C++有固定的成员初始化次序:base classes初始化早于其derived classes,class成员变量初始化顺序按照声明次序(即使在成员初值列中次序不同,但最好以声明次序写成员初值列。

 

有关“不同编译单元内定义的non-local static对象”的初始化顺序

Static对象的寿命从被构造出来直到程序结束为止,包括global对象、定义于namespace作用域内的对象、classes内、函数内、file作用域内被声明为static的对象;

函数内的static对象称为local static对象,其他static对象称为non-local static对象;

程序结束时static对象会被自动销毁;

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

问题:如果某个编译单元内某个non-local static对象的初始化动作使用了另一编译单元内的某个non-local static对象,因为C++对“定义于不同编译单元内的non-local static对象的初始化次序”无明确定义,它所用到的这个对象可能尚未被初始化。

解决办法:将每个non-local static对象搬到自己专属函数内,该对象在此函数内被声明为static,函数返一个指向它所含对象的reference;

用户调用这些函数,而不直接指涉这些对象(用local-static替换non-local static);

原理:Singleton模式的一个实现收发,保证函数内的local static对象会在函数调用期间首次遇上该对象定义式时被初始化,如:

FileSystem& tfs() {
    static FileSystem fs; //替换local static tfs
    return fs;
}
Directorry::Directory(params) {
    std::size_t disks = tfs(). numDisks();//原先使用reference to tfs
}
Directory& tempDir() {
    static Directory td; //替换local static tempDir
    reutrn td;
}

 

C++自动编写并调用copy构造/析构/copy赋值运算

 

如果没有声明copy构造函数、copy assignment操作符和析构函数,C++处理后编译器将自动声明copy构造函数和析构函数;

 

编译器自动声明的copy构造函数单纯将来源对象的每个non-static成员变量(调用成员变量的copy构造函数)拷贝到目标对象;

 

编译器自动声明的copy assignment操作符与copy构造函数类似,但如果生成代码不合法,编译器会拒绝自己生成operator=编译赋值行为,如以下三种情况:

1. 如果要在内含reference成员的class内支持赋值操作,编译器拒绝生成copy assignment,必须自己定义copy assignment操作符;

2. 如果要在内含const成员的class内支持赋值操作,更改const成员不合法,编译器拒绝生成copy assignment;

3. 如果base class将copy assignment操作符声明为private,编译器拒绝为其derived classes生成copy assignment操作符,因为所生成的copy assignment操作符将无法调用derived class无权调用的成员函数;

如果没有声明任何构造函数,编译器也会声明一个default构造函数;

这些函数都是public且inline的,当需要调用这些函数时才会被编译器创建;

编译器调用的析构函数是non-virtual的,除非该class的base class自身声明有virtual析构函数;

 

若不想使用编译器自动生成的函数需明确阻止

 

特定对象可能需要阻止对其进行copy操作,如果需要阻止编译器自动生成的函数(如copy构造函数或copy assignment操作符),可以将这些函数声明为private且不添加定义;

 

例:C++标准程序库iostream实现码中的ios_base, basic_ios, sentry的copy构造函数和copy assignment操作符都被声明为private且没有定义;

 

防止编译器暗自生成及他人调用,可将copy构造函数和copy assignment操作符声明为private,客户企图拷贝对象时会被编译器阻止:

class HomeForSale {
  public:
      ...
  private:
      ...
      HomeForSale(const HomeForSale&); //只有声明
      HomeForSale(const HomeForSale&); 
};

防止member和friend函数调用,可不为copy构造函数和copy assignment操作符添加定义,但报错会发生在连接器。为将连接期错误移至编译器,可为对象创建base class,在base class内将copy构造函数和copy assignment操作符声明为private:

class Uncopyable { //base class
  protected:
      Uncopyable(){} //允许derived对象构造和析构
      ~Uncopyable(){}
  private:
      Uncopyable(const Uncopyable&); //但阻止copying
      Uncopyable operator=(const Uncopyable&);
};

class HomeForSale : private Uncopyable { //derived class
  ... //不再声明copy构造函数或copy assignment操作符
}

 

为多态基类声明virtual析构函数

 

注意将多态基类的析构函数声明为virtual,因为如果base class有non-virtual的析构函数,derived class对象的析构函数未能执行,derived成分无法经由base class指针销毁,形成资源泄露;

 

给base class声明virtual析构函数,删除derived class对象时能够完整销毁整个对象:

class TimeKeeper {
  public:
      TimeKeeper();
      virtual ~TimeKeeper();
      ...
};
TimeKeeper* ptk = getTimeKeeper();//从TimeKeeper继承体系获得一个动态分配对象
...
delete ptk;//释放避免资源泄露

Virtual函数的实现细节:每个带有virtual函数的class都有相应的由函数指针构成的数组vtbl(virtual table)。对象携带vptr(virtual table pointer)指针,指向vtbl。当对象调用某一virtual函数时,实际被调用的函数取决于该对象的vptr所指的vtbl,编译器在vtbl中寻找适当的函数指针。

如果class不需要作为base class(class内往往不含有virtual函数),则不需要令其析构函数为virtual。

标准容器如string,STL容器如vector, list, set, trl::unordered_map等都不含有virtual析构函数,应避免继承此类带有non-virtual析构函数的class导致析构函数未有定义出现资源泄露问题。

 

如果需要创建抽象(abstract)对象,可为其声明pure virtual函数并提供空白定义:

class AWOV {
  public:
      virtual ~AWOV() = 0;
};
AWOV::~AWOV() {}

 

析构函数的运作方式:最深层派生(most derived)的class的析构函数最先被调用,每个base class逐渐被调用,为derived classes的析构函数提供定义,创建对~baseclass的调用动作(否则连接器报错)。

 

析构函数绝对不要吐出异常

 

注意:析构函数绝对不要吐出异常,否则会导致程序过早结束或不明确行为。如果一个被析构函数调用的函数可能抛出异常,析构函数内应该捕捉任何异常,吞下或结束程序。

 

如果客户需要对某个操作函数运行期间抛出的异常做出反应,class应提供一个普通函数(在析构函数之外)执行该操作。如:

 

class DBConnection {
  public:
      ...
      static DBConnection cereate();
      void close();//关闭连接,失败则抛出异常
}

class DBConn { //用于管理DBConnection对象
  public:
      ...
      void close() {//供客户对可能出现的问题做出反应
          db.close(); //确保数据库连接关闭
          close = true;
      }
      ~DBConn() {
          if(!closed) {
              try {
                  db.close();
              } catch(...) {
                  ...//如果关闭失败,记录下来并吞下异常,或结束程序
              }
          }
      }
  private:
      DBConnection db;
      bool closed;
};

//客户使用
{ DBConn dbc(DBConnection::create());
    ...}//区块结束,DBConn销毁

 

绝对不要在构造函数和析构函数内调用virtual函数

 

由于无法在构造和析构期间无法使用virtual函数从base class向下调用到derived class,如果需要确保每次base class的继承体系上的对象被创建时都会有适当版本的成员函数被调用,可采用将该函数改为non-virtual,要求derived class构造函数传递必要信息给base class构造函数,构造函数从而安全调用non-virtual函数的做法:

class Transaction {//base class
  public:
      explicit Transaction(const std::string& logInfo);
      void logTransaction(const std::string& logInfo) const; //根据不同类型做出不同的日志记录
      ...
};

Transaction::Transaction(const std::string& logInfo) {
    ...
    logTransaction(logInfo);
}

class BuyTransaction : public Transaction { //derived class
  public:
      BuyTransaction(parameters) 
      : Transaction(createLogString(parameters)) 
      {...} //将log信息传给base class构造函数
     ...
  private:
      static std::string createLogString(parameters);
};

利用辅助函数static std::string createLogString(parameter)创建一个值传给base class构造函数,比在成员初值列内给予base class所需数据更方便、可读;

此函数为static,避免了意外指向“初期未成熟的derived class对象内尚未初始化的成员变量”。

 

operator=应返回*this的引用

 

标准赋值oprator=及其他赋值如+=,-=,*=等应遵守协议返回reference to *this(指向左侧【当前】对象的reference),从而实现“连锁赋值”(如x=y=z=15,解析为右结合律);

class Widget {
  public:
      ...
  Widget& operator=(const Widget& rhs) {
      ...
      return *this; //返回类型为指向当前对象的reference
  }
}

非强制性,违反协议一样可通过编译,但该协议被所有内置类型和标准程序库共同遵守;

 

在编写operator=时需考虑自我赋值操作的情况,如:

w=w;

a[i] = a[j] (i=j时)

*px = *py; (px和py指向同一处)忽略自我赋值问题指针可能指向已被删除的对象;

处理方法:提前做证同测试(identity test),检验自我赋值情况:

Widget& Widget::operator(const Widget& rhs) {
if (this == &rhs) return this; //identity test
delete pb; //pb为对象持有的指针
pb = newBitmap(*rhs.pb);
return *this;
}

仍存在不具备异常安全性的问题,如果因为分配时内存不足或copy构造函数抛出异常导致new()异常,持有指针可能仍会指向已被删除的对象;

让operator具备异常安全性的做法:在复制指针所指对象前先别delete该指针,如果new()抛出异常,指针和指针原指的对象能够保持原状。

Widget& Widget::operator=(const Widget& rhs) {
    If(this==&rhs) return *this;
    Bitmap* pOrig = pb; //记住原先持有的指针
    pb = new Bitmap(*rhs.pb) //令pb指向*pb的一个副本
    delete pOrig; //删除原先的pb
    return this;
}

 

复制对象时需注意复制所有成分

为derived class编写copying函数时需要记得除local成员变量外,还需复制base class成分,其中base class的private成分无法直接访问,应在derived class的copying函数内调用相应的base class函数:

PriorityCustomer::PriorityCustomer(const PriorityCustomer& rhs)
 : Customer(rhs), PriorityCustomer(rhs.priority) { //调用base class Customer的构造函数
     logCall("PriorityCustomer copy constructor");
 }
 PriorityCustomer& PriorityCustomer::operator=(const PriorityCustomer& rhs) {
     logCall("PriorityCustomer copy assignment operator");
     Customer::operator=(rhs); //对base class成分进行赋值
     return *this;
 }

 


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
C#实现播放RTSP标准协议码流播放发布时间:2022-07-13
下一篇:
C#将HTML转为XML发布时间:2022-07-13
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap