effectiveC++ 内存管理 学习笔记


1.尽量使用初始化列表而不要再构造函数里赋值,初始化顺序和声明的顺序一致,一些类型如const,引用等,必须使用初始化。对于非内部数据类型成员对象应当采用初始化表,以获取更高的效率。
example:
B::B(const A& a):m_a(a){}只调用了类A的拷贝构造函数
2.基类都使用虚析构函数,这样才能在使用多态时,准确的析构派生类
3.operator>>和operator<<决不能是成员函数。如果f是operator>>或operator<<,让f成为非成员函数。如果f还需要访问c的非公有成员,让f成为c的友元函数。在类的内部,它可以用于静态和非静态成员。
4.尽可能使用const.const关键字实在是神通广大。在类的外面,它可以用于全局或名字空间常量,以及静态对象(某一文件或程序块范围内的局部对象)。在类的内部,它可以用于静态和非静态成员.
对指针来说,可以指定指针本身为const,也可以指定指针所指的数据为const,或二者同时指定为const,还有,两者都不指定为const:
char *p = "hello"; // 非const指针,
// 非const数据
const char *p = "hello"; // 非const指针,
// const数据
char * const p = "hello"; // const指针,
// 非const数据
const char * const p = "hello"; // const指针,
// const数据
5.尽量用“传引用”而不用“传值”
“通过值来传递一个对象”的具体含义是由这个对象的类的拷贝构造函数定义的。这使得传值成为一种非常昂贵的操作。
为避免这种潜在的昂贵的开销,就不要通过值来传递对象,而要通过引用:
const student& returnstudent(const student& s)
{ return s; }
这会非常高效:没有构造函数或析构函数被调用,因为没有新的对象被创建。

6.返回值:对于赋值函数,应当用“引用传递”的方式返回对象,对于相加函数应当用值传递,因为引用对象在函数结束时被销毁。

例如:

class String  
{…  
    // 赋值函数  
    String & operate=(const String &other);   
        // 相加函数,如果没有friend修饰则只许有一个右侧参数  
        friend  String   operate+( const String &s1, const String &s2);   
private:  
    char *m_data;   
}  
  
//String的赋值函数operate = 的实现如下:  
String & String::operate=(const String &other)  
{  
    if (this == &other)  
        return *this;  
    delete m_data;  
    m_data = new char[strlen(other.data)+1];  
    strcpy(m_data, other.data);  
    return *this;   // 返回的是 *this的引用,无需拷贝过程  
}  

对于赋值函数,应当用“引用传递”的方式返回String对象。如果用“值传递”的方式,虽然功能仍然正确,但由于return语句要把 *this拷贝到保存返回值的外部存储单元之中,增加了不必要的开销,降低了赋值函数的效率。例如:

String a,b,c;

a = b; // 如果用“值传递”,将产生一次 *this 拷贝
a = b= c; // 如果用“值传递”,将产生两次 *this 拷贝
对于相加函数,应当用“值传递”的方式返回String对象。如果改用“引用传递”,那么函数返回值是一个指向局部对象temp的“引用”。由于temp是在栈上申请的变量,函数执行完毕后被销毁,将导致返回的“引用”无效。

//String的相加函数operate + 的实现如下:  
String  operate+(const String &s1, const String &s2)    
{  
    String temp;  
    delete temp.data;   // temp.data是仅含‘\0’的字符串  
    temp.data = new char[strlen(s1.data) + strlen(s2.data) +1];  
    strcpy(temp.data, s1.data);  
    strcat(temp.data, s2.data);  
    return temp;  
}  

如果函数返回值是一个对象,要考虑return语句的效率。例如
return String(s1 + s2);
这是临时对象的语法,表示“创建一个临时对象并返回它”。不要以为它与“先创建一个局部对象temp并返回它的结果”是等价的,如
String temp(s1 + s2);
return temp;
实质不然,上述代码将发生三件事。首先,temp对象被创建,同时完成初始化;然后拷贝构造函数把temp拷贝到保存返回值的外部存储单元中;最后,temp在函数结束时被销毁(调用析构函数)。然而“创建一个临时对象并返回它”的过程是不同的,编译器直接把临时对象创建并初始化在外部存储单元中,省去了拷贝和析构的化费,提高了效率。

7.划分全局名字空间的好处
例如,假设library1.h定义了一些常量,其中包括:

const double lib_version = 1.204;

类似的,library2.h也定义了:

const int lib_version = 3;

很显然,如果某个程序想同时包含library1.h和library2.h就会有问题。

要这么做:

namespace sdm {
  const double book_version = 2.0;
  class handle { ... };
  handle& gethandle();
}

用户于是可以通过三种方法来访问这一名字空间里的符号:将名字空间中的所有符号全部引入到某一用户空间;将部分符号引入到某一用户空间;或通过修饰符显式地一次性使用某个符号:

void f1()
{
  using namespace sdm;           // 使得sdm中的所有符号不用加
                                 // 修饰符就可以使用

  cout << book_version;          // 解释为sdm::book_version
  ...

  handle h = gethandle();        // handle解释为sdm::handle,
                                 // gethandle解释为sdm::gethandle
  ...                            

}

void f2()
{
  using sdm::book_version;        // 使得仅book_version不用加
                                 // 修饰符就可以使用

  cout << book_version;           // 解释为
                                  // sdm::book_version
  ...

  handle h = gethandle();         // 错误! handle和gethandle
                                  // 都没有引入到本空间
  ...                             

}

void f3()
{
  cout << sdm::book_version;      // 使得book_version
                                  // 在本语句有效
  ...                             

  double d = book_version;        // 错误! book_version
                                  // 不在本空间

  handle h = gethandle();         // 错误! handle和gethandle
                                  // 都没有引入到本空间
  ...                            

}

8.将文件间的编译依赖性降至最低
假设某一天你打开自己的C++程序代码,然后对某个类的实现做了小小的改动。提醒你,改动的不是接口,而是类的实现,也就是说,只是细节部分。然后你准备重新生成程序,心想,编译和链接应该只会花几秒种。毕竟,只是改动了一个类嘛!于是你点击了一下"Rebuild",或输入make(或其它类似命令)。然而,等待你的是惊愕,接着是痛苦。因为你发现,整个世界都在被重新编译、重新链接!
在name.h中定义
class name{};
在person.h中:

#include"name.h"
class person{
public:
person(const name& _pname);
virtual ~Person();
private:
name _pname;//实现细节
string namestr() const;
};

在其他文件中:
class man:public person{
...
};
class woman:public person{
...
};

这时候person文件和name.h之间建立了编译依赖关系,如果name改变了它的实现,或者name依赖的类改变了实现,包含person类的文件以及任何使用了person类的文件就必须重新编译。这时person,man,和woman的文件都要重新编译。
为了实现定义与实现细节分开,我们可以这样定义person:

class name;//提前声明
class person{
public:
person(const name& _pname);
virtual ~Person();
private:
string namestr() const;
};

如果这样做可行,person的用户就不需要重新编译,只可惜用起来才知道:

int main()
{
int x;//定义一个int
person p(new name);//定义一个person
}

当看到x的定义时,编译器知道必须为它分配一个int大小的内存。这没问题,每个编译器都知道一个int有多大。然而,当看到p的定义时,编译器虽然知道必须为它分配一个person大小的内存,但怎么知道一个Person对象有多大呢?
对应于上面的代码,或许可以这样做:

int main()
{
  int x;                     // 定义一个int
  Person *p;                 // 定义一个Person指针,编译器知道是4字节
  ...
}

下面具体介绍怎么采用这一技术来实现person接口和实现的分离:

class name;//提前声明
class man;
class woman;
class person{
public:
person(const name& _pname);
virtual ~Person();
man *personimpl1;//指向具体实现类
woman *personimpl2;
string namestr() const;
};
//在person.cpp中:
#include"person.h"
#include"man.h"
person.cpp::person(const name& _pname)
{
personimpl1 = new man(_pname);
}
string person::namestr()const
{
return personimpl1->name();
}

这样,person作为接口与实现完全分离。编译时不对name的改变产生依赖

posted @ 2013-08-19 16:37  newShit  阅读(665)  评论(0编辑  收藏