第12章 类和动态内存分配

1.静态类成员

      // strngbad.h -- flawed string class definition ... class StringBad { private: ... static int num_strings; // number of objects public: ... }; // strngbad.cpp -- StringBad class methods ... int StringBad::num_strings = 0;

      上面是静态成员的创建方式。无论创建了多少对象，程序都只创建一个静态类变量副本。不能在类声明中初始化静态成员变量，这是因为声明描述了如何分配内存，但并不分配内存。静态类成员可以在类声明之外使用单独的语句来进行初始化，因为静态类成员是单独存储的，而不是对象的组成部分。

      静态数据成员在类声明中声明，在包含类方法的文件中初始化。初始化时使用作用域操作符来指出静态成员所属的类。但如果静态成员是整型或枚举型const，则可以在类声明中初始化。

2.复制构造函数

       复制构造函数用于将一个对象复制到新创建的对象中，它用于初始化过程中，而不是常规的赋值过程中。将新对象显式地初始化为现有的对象时，复制构造函数都将被调用。下面4种声明都将调用复制构造函数：

Stringbad ditto(motto); Stringbad metoo = motto; Stringbad also = Stringbad (motto); Stringbad * pStringbad = new Stringbad(motto);

      中间的2个声明可能会使用复制构造函数直接创建metoo和also，也可能使用复制构造函数生成一个临时对象，然后将临时对象的内容赋给metoo和also，这取决于具体的实现。最后一种声明使用motto初始化一个匿名对象，并将新对象的地址赋给pStringbad指针。

      每当程序生成了对象副本时，编译器都将使用复制构造函数。具体地说，当函数按值传递对象或函数返回对象时，都会使用。

      下述情况，将使用复制构造函数：将新的对象初始化为一个同类对象；将值按对象传递给函数；函数按值返回对象；编译器生成临时对象。

      默认的复制构造函数逐个复制非静态成员（成员复制也称为浅复制），复制的是成员的值。如果类中包含的静态数据成员在新对象被创建时发生变化，则应该提供一个显式构造函数来处理该变化问题。如果类中包含了使用new初始化的指针成员，也应当定义一个复制构造函数，以复制指向的数据，而不是指针，这被称为深度复制。浅复制仅浅浅地复制指针信息，而不会深入“挖掘”来复制指针引用的结构。

StringBad::StringBad(const StringBad & st) { num_strings++; len=st.len; str=new char[len+1]; std::strcpy(str,st.str); cout<<num_string<<":/""<<str<<"/"object created/n"; }

3.赋值操作符

      C++允许类对象赋值，这是通过自动为类重载赋值操作符实现的。它的隐式实现也对成员进行逐个复制，但静态数据成员不受影响。原型如下：Class_name & Class_name::operator= (const Class_name &);

      由于默认赋值操作符不合适而导致的问题，解决办法是提供赋值操作符（进行深度复制）定义。其实现与复制构造函数相似，但也有一些差别：

      1）由于目标对象可能引用了以前分配的数据，所以函数应使用deletep[]来释放这些数据。

      2）函数应当避免将对象赋给自身；否则，给对象重新赋值之前，释放内存操作可能删除对象的内容。

      3）函数返回一个指向调用对象的引用。

      注意，赋值操作符只能由类的成员函数重载。

StringBad & StringBad::operator=(const StringBad & st) { if(this = & st) return *this; delete [] str; len = st.len; str = new char [len+1]; std::strcpy(str,st.str); return *this; }

4.静态类成员函数

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/1.jpg

5.构造函数中使用new时应注意的事项

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/2.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/3.jpg

下面是3个构造函数范例：

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/4.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/5.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/6.jpg

6.有关返回对象的说明

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/7.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/8.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/9.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/10.jpg

https://p-blog.csdn.net/images/p_blog_csdn_net/xuanya0214/EntryImages/20091013/11.jpg

7.再谈布局new操作符

      系统不会为使用布局new操作符创建的对象调用析构函数。所以必须显示使用布局new操作符创建对象的析构函数。

#include <iostream> #include <string> #include <new> using namespace std; const int BUF = 512; class JustTesting { private: string words; int number; public: JustTesting(const string & s = "Just Testing", int n = 0) {words = s; number = n; cout << words << " constructed/n"; } ~JustTesting() { cout << words << " destroyed/n";} void Show() const { cout << words << ", " << number << endl;} }; int main() { char * buffer = new char[BUF]; // get a block of memory JustTesting *pc1; pc1 = new (buffer) JustTesting; // place object in buffer cout << "Memory block addresses:/n" << "buffer: " << (void *) buffer<<endl; cout << "Memory contents:/n"; cout << pc1 << ": "; pc1->Show(); JustTesting *pc3; // fix placement new location pc3 = new (buffer + sizeof (JustTesting)) JustTesting("Better Idea", 6); cout << "Memory contents:/n"; cout << pc3 << ": "; pc3->Show(); // explicitly destroy placement new objects pc3->~JustTesting(); // destroy object pointed to by pc3 pc1->~JustTesting(); // destroy object pointed to by pc1 delete [] buffer; // free buffer cout << "Done/n"; return 0; }

8.在类中嵌套结构或类声明

      在类声明中声明的结构、类或枚举被称为是被嵌套在类中，其作用域为整个类。这种声明不会创建数据对象，而只是指定了可以在类中使用的类型。如果声明是在类的私有部分进行的，则只能在这个类使用被声明的类型；如果声明是在公有部分进行的，则可以在类的外部通过作用域解析操作符使用被声明的类型。如果Node是在Queue类的公有部分声明的，则可以在类的外面声明Queue::Node类型的变量。

      下面是队列的类声明：

class Queue { private: //class scope definition struct Node { Item item; struct Node * next; }; enum { Q_size = 10 }; //private class member Node * front; Node * rear; int items; const int qsize; ... public: ... }

9.成员初始化列表法

     如果Classy是一个类，而mem1、mem2和mem3都是这个类的数据成员，则类构造函数可以使用如下的句法来初始化数据成员：

Classy::Classy( int n, int m): mem1 (n), mem2 (0), mem3 (n*m+2) { ... }

    从概念上说，这些初始化工作都是在对象创建时完成，此时还未执行括号中的任何代码。注意：

    1）这种格式只能用于构造函数；

    2）必须用这种格式来初始化非静态const数据成员，如第8点中的qsize成员。

    3）必须用这种格式来初始化引用数据成员。如：

class A { ... }; class B { private: A & belong; ... }; B::B(A &mem):belong(mem) { ... }