Effective C++ 读书笔记(一)

最新推荐文章于 2024-06-03 14:23:01 发布

张哲BJUT

最新推荐文章于 2024-06-03 14:23:01 发布

阅读量3k

点赞数

分类专栏： C＋＋文章标签： C++

本文链接：https://blog.csdn.net/zhangzhebjut/article/details/20161947

版权

C＋＋专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.C++ 高效编程守则视状况而变化，取决于你使用C++的哪一部分

C++主要包括：C、Object-Oriented C ++、Template C++以及STL

2.对于单纯常量，最好以const对象或enums替换 #define

对于形似函数的宏，最好改用inline函数替代 #define

#include <iostream>
using namespace std;
#define CALL_WITH_MAX(a,b) f((a)>(b)?(a):(b))

void f(int x)
{
//cout << x << endl;
}

inline void callWithMax(const int &a,const int &b)
{
f(a>b?a:b);
}

class GamePlayer
{
public:
    static const int NumTurns = 5;  //常量表达式
    enum {NumTurns01 = 5};
    int scores[NumTurns];
    char str[NumTurns01];

};

3.令某些东西声明为const可帮助编译器侦测出错误用法。用const可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。

解释：const 出现在星号左边，表示所指物是常量；如果出现在星号右边，表示指针自身是常量；

const int *p 和 int const *p表达的意思是一样的。

声明迭代器为const就像声明指针为const一样（T*const指针),表示迭代器不得指向不同的东西，但它所值的东西是可以改动的。如果你希望迭代器所指向的东西不可以被改动，你需要使用const_iterator。

const成员函数：

a. 它们使class接口比较容易被理解，这是因为，得知哪个函数可以被改动对象内容而哪个函数不行，很是重要的。

b. 它们使“操作const对象”成为可能。

注意：两个成员函数如果只是常量性不同，可以被重载。

编译器强制实施bitwise constness, 但你编写程序时应该使用“概念上的常量性”。

解释：当const和none-const成员函数有着实质等价的实现时，令non-const版本调用const版本可避免重复。如果在const函数内部调用non-const函数，是错误的：因为对象有可能因此被改动，但反向调用是安全的，non-const成员函数本来就是对其对象做任何动作，所以在其中调用一个const成员函数并不会带来风险。

bitwise constnes（物理常量）：成员函数只有在不更改对象之任何成员变量时才可以说是const，也就是说不更改对象内的任何一个bit。

概念常量：一个const成员函数可以修改它所处理的对象内的某些bit.

可以使用mutable释放non-static成员变量的bitwise constness约束。

当const和非const成员函数有着实质等价的实现时，令non-const版本调用const版本可避免代码重复。

class TextBlock
{
public:
    TextBlock(string aStr=""):text(aStr){}
    const char& operator[](size_t postion) const {cout <<"const const version."; return text[postion];}
    char& operator[](size_t position) {cout << "none version.";return text[position];}
  size_t getLength() const {length = 10; return length;}
private:
    string text;
    mutable size_t length;
    mutable bool isValid;
}
char& TextBlock::operator[](size_t position)
{
    return const_cast<char &>(static_cast<const TextBlock>(*this)[position]);

}

4. 为内置类型对象进行手动初始化，因为C++不保证初始化它们。

构造函数最好使用成员初始化列表，而不是在构造函数本体内使用赋值操作。初始化列表列出的成员变量，其次序应该和它们在class 中的声明次序相同

为免除“跨编译单元之间初始化次序”问题，请以local static对象替换non-local static对象。

5.编译器可以暗自为class 创建default构造函数、拷贝构造函数、赋值运算符重载函数以及析构函数，且这些函数的都是public的且inline。

注意：无论是编译器生成的，或用户自定义的析构函数都会自动调用其non-static成员变量的析构函数。

默认构造函数和析构函数主要是给编译器一个地方用来放置“藏身幕后”的代码，像是调用base classes和non-static成员变量的析构函数和构造函数。

注意：

1.编译器产生的析构函数是一个non-virtual，除非这个class的base class 自身声明有virtual析构函数。

2.如果某个基类将赋值运算符重载函数声明为private,编译器将拒绝为其派生类生成一个赋值运算符重载函数。毕竟编译器为派生类所生成的赋值运算符函数想象中可以处理基类的成分，但它们当然无法调用派生类的成员无权调用的成员函数。编译器两手一摊，无能为力。此时编译器拒绝赋值动作。

3. 如果在一个“内含reference成员或const成员”的class内支持赋值操作，你必须自己定义赋值运算符重载函数。

#include <iostream>

#include <string>

using namespace std;

template < typename T>

class NamedObject

{

template < typename T> friend ostream& operator <<(ostream& os, const NamedObject<T> &object);

public :

NamedObject(string& name, const T& value);

NamedObject& operator =( const NamedObject& object);

void SetNameValue(string& name) {nameValue = name;}

private :

string& nameValue;

const T objectValue;

};

template < typename T>

NamedObject<T>::NamedObject(string& name, const T& value):nameValue(name),objectValue(value)

{

}

template < typename T>

ostream& operator <<(ostream& os, const NamedObject<T> &object)

{

os << "name:" << object.nameValue << " value:" << object.objectValue << endl;

return os;

}

template < typename T>

NamedObject<T>& NamedObject<T>:: operator =( const NamedObject<T>& object)

{

if ( this == &object)

return * this ;

this ->nameValue = object.nameValue;

return * this ;

}

int main( int argc, char **argv)

{

//string s("hello");

//string &p = s;

//p = "world";

//cout << s << endl;

string p = "p" ;

string s = "s" ;

//string& p2 = p;

//string& s2 = s;

//p2 = s2;

NamedObject < int > p1(p,1);

p1.SetNameValue(s);

cout << p1; //s

cout << p<< endl;; //s

NamedObject< int > s1(s,2);

//p1 = s1; //error C2582: “operator =”函数在“NamedObject<T>”中不可用

s = "p" ;

p1 = s1;

cout << p1; //p

cout << endl;

return 0;

}

6.为驳回编译器自动(暗自)提供的功能，可将相应的成员函数声明为private并且不予实现。不过这种方法并不绝对安全，因为member函数和friend函数还是可以调用你的private函数。

使用像Uncopyable这样的base class也是一种方法。

例如：

class Uncopyable

{
protected:
    Uncopyable(){}
    ~Uncopyable(){}
private:
    Uncopyable(const Uncopyable&);
    Uncopyable& operator=(const Uncopyable&);
};
class MyClass: private Uncopyable
{
};
int main(int argc, const char * argv[])
{
    MyClass obj01;
    MyClass obj02(obj01); //Error

obj01 = obj02; //Error

}

当尝试拷贝MyClass对象时候，编译器便试着生成一个拷贝构造函数和一个赋值运算符重载函数，这些函数的“编译器生成版本”会尝试调用其base class的对应的兄弟，那些调用会被编译器拒绝，因为其base class的拷贝构造函数是private。

7.带多态性质的base classes应该声明一个virtual析构函数。如果class带有任何virtual函数，它就应该拥有一个virtual析构函数。

Classes的设计目的如果不是作为base classes使用，或不是为了具备多态性，就不应该声明为virutal析构函数。

当derived class对象经由一个base class指针被删除，而该base class带着一个non-virtual析构函数，其结果未有定义---实际执行时通常发生的是对象的derived成分没被销毁。

注：1.所有STL容器不带virtual析构函数。

2.可以将一个类的析构函数声明为纯析构函数，但是你必须为其提供一份定义。

8.析构函数绝对不能吐出异常。如果一个被析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它们（不传播）或结束程序。

如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数（而非在析构函数中）执行该操作。

如果某个操作在失败时抛出异常，而又存在某种需要必须处理该异常，那么这个异常必须来自析构函数以为的某个函数。如果析构函数吐出异常就是危险，总会带来“过早结束程序”或“发生不明确行为”的风险。

9.在构造函数和析构函数内不要调用virtual函数，因为这类调用从不下降至derived class（比起当前执行构造函数和析构函数的那层）。

10.令赋值操作符返回一个reference to *this.

11.确保当对象自我赋值时operator=有良好的行为。其中技术包括比较“来源对象”和“目标对象”的地址，精心周到的语句顺序以及copy and swap.

/*
考虑异常安全性的解法（Exception Safety)原则
*/
CMyString& CMyString::operator=(const CMyString &str)
{
   if (this != &str)
   {
       CMyString strTemp(str);

       char *PTemp = strTemp.m_pData;
       strTemp.m_pData = m_pData;
       m_pData = PTemp;
   }
    return *this;
}