【捡起C++】类和动态内存分配
C++在内存分配时，让程序在运行时决定内存分配，而不是编译时决定。
C++使用new 和 delete来动态控制内存。
//strngbad.h -- flawed string class definition
#include 将这个类命名为StringBad是因为这是一个不太完整的类。它是使用动态内存分配来开发类的第一个阶段，正确地完成了一些显而易见的工作。
num_strings 为静态存储类，即使创建了10个StringBad对象，但也只有一个共享的num_strings成员。
//strngbad.cpp -- StringBad class methods
#include //vegnews.cpp -- using new and delete with classes
//compile with strngbad.cpp
#include callme2(headline2) ，将headline2作为函数参数来传递从而导致析构函数被调用。虽然 按值传递可以防止原始参数被修改，但实际上函数已使原始字符串无法识别。
StringBad sailor = sports;
这种初始化等同于
StringBad sailor = StringBad(sports);//StringBad(const StringBad&)
当使用一个对象来初始化另一个对象时，编译器将自动生成上述构造函数（称为复制构造函数）。自动生成的构造函数不知道要更新静态变量num_string，因此会将技术方案搞乱。析构函数上也会有一些问题（同一块内存释放两次）。
复制构造函数原型通常是：
Class_name(const Class_name&);
定义一个显示的复制构造函数
StringBad::StringBad(const StringBad & st){
num_strings++;
len = st.len;
str = new char[len + 1];
std::strcpy(str, st.str);
cout << num_strings << ": \" " << str << "\" object created\n";
}
StringBad类的其他问题
c++允许类对象赋值，这是通过自动为类重载赋值运算符实现的。这种运算符原型如下：
Class_name & Class_name::operator=(const Class_name &);
赋值运算符的功能以及何时使用
StringBad headline1("Celery Stalks at Midnight");
...
StringBad knot;
knot = headline1; //使用赋值运算符
//初始化对象时不一定使用
StringBad metoo = knot;// 使用拷贝构造函数
上述代码中
knot = headline1;
与拷贝构造函数一样，析构时，headline1.str和knot.str指向了同样的地址。
重载赋值运算符（重要）
StringBad & StringBad::operator=(const StringBad& st){
if(this == &st){
return *this;
}
delete[] str; //free old string
len = st.len;
str = new char[len + 1];
std::strcpy(str, st.str);
return *this;
}
代码首先检查自我复制，如果相同，直接返回*this。接着释放掉str指向的内存。
改进后的新String类
#ifndef STRING1_H_
#define STRING1_H_
#include#pragma warning(disable:4996)
#include#include:\n" ;
String sayings[ArSize]; // 对象数组
char temp[MaxLen];
int i;
for (i = 0; i < ArSize; i++)
{
cout << i + 1 << ": ";
cin.get(temp, MaxLen);
while (cin && cin.get() != '\n')
continue;
if (!cin || temp[0] == '\0') // empty line? 后半部分用于旧版本的检测空行
break;
else
sayings[i] = temp;
}
int total = i; // total # of lines read
if (total > 0)
{
cout << "Here are your sayings:\n";
for (i = 0; i < total; i++)
cout << sayings[i][0] << ": " << sayings[i] << endl;
int shorest = 0;
int first = 0;
for (i = 1; i < total; i++)
{
if (sayings[i].length() < sayings[shorest].length())
shorest = i;
if (sayings[i] < sayings[first])
first = i;
}
cout << "Shortest saying:\n" << sayings[shorest] << endl;
cout << "First alphabetically:\n" << sayings[first] << endl;
cout << "This program used " << String::HowMany() << " String objects. Bye.\n";
}
else
cout << "No input! Bye.\n";
return 0;
}
在构造函数中使用 new 时应注意的事项
- 在构造函数中使用 new 来初始化指针成员，则应在析构函数使用 delete；
- new 和 delete 必须互相兼容。new 对应于 delete，new [ ] 对应于 delete [ ]；
- 只有一个析构函数，如果有多个构造函数，必须以相同的方式使用 new，所有的构造函数都必须与它兼容；
- delete （无论带不带 [ ]）可以用于空指针（NULL、0、nullptr）；
- 定义一个复制构造函数，通过深度复制将对象初始化为另一个对象：
String :: String ( const String & st )
{
num_string++； // 更新静态成员
len = st.len；
str = new char [ len + 1 ]； // 分配新地址空间
std::strcpy(str，st.str)； // 把字符串复制到新的地址
}
- 定义一个赋值运算符，通过深度复制将一个对象复制给另一个对象：
String & String :: operator = ( const String & st )
{
if ( this == &st ) // 检查自我赋值情况
return *this；
delete [ ] str； // 释放成员指针以前指向的内存
len = st.len；
str = new char [ len + 1 ]； // 为复制数据分配内存，而不是仅仅数据的地址
std :: strcpy( str，st.str )；
return *this； // 返回一个指向调用对象的引用
}
有关返回对象的说明
当成员函数或独立的函数返回对象时，有几种返回方式可供选择：
* 指向对象的引用；
* 指向对象的 const 引用；
* const 引用；
返回指向 const 对象的引用
使用 const 引用的常见原因是旨在提高效率：
返回对象将调用复制构造函数，而返回引用不会；
引用指向的对象应该在调用函数执行时存在；
参数被声明为 const 引用，返回类型必须为 const；
返回指向非 const 对象的引用
operator = () 的返回值用于连续赋值：
Sring s1 ( “Good stuff” )；
String s2， s3；
s3 = s2 = s1；
返回类型不是 const 因为方法 operator = () 返回一个指向 s2 的引用，可以对其进行修改。返回引用可以不调用复制构造函数
operator << ( ) 的返回值用于串接输出：
String s1( “Good stuff” )；
cout << s1 << “is coming!”；
operator << ( cout， s1 ) 的返回值成为一个用于显示字符串 " is coming! "的对象；
返回类型必须为 ostream &，而不能是 ostream，因为 ostream 没有公有的复制构造函数
返回对象
如果返回的对象是调用函数中的局部变量，不能按引用返回它，被调用函数执行完毕后，局部对象将调用其析构函数，引用指向的对象不再存在；
返回对象而不是引用，将调用复制构造函数
返回方式总结
如果方法或函数要返回局部对象，则应返回对象，而不是指向对象的引用，将使用复制构造函数来生成返回的对象；
如果方法或函数返回一个没有公有复制构造函数的类的对象，它必须返回这种对象的引用；
有些方法和函数（如重载的赋值运算符）可以返回对象，也可以返回指向对象的引用，首选引用，因为效率高。
复习各种技术
重载 << 运算符
要重新定义 << 运算符，以便将它和 cout 一起用来显示对象的内容，定义下面友元运算符函数：
ostream & operator << (ostream & os， const c_name & obj )
{
os << . . . ； // display object contents
return os；
}
其中 c_name 为类名， 如果该类能够返回所需内容的公有方法，则可以在运算符中使用这些方法，这样便不用将它们设置为友元函数了
转换函数
要将单个值转换为类类型，需要定义类构造函数：
c_name ( type_name value )； // c_name为类名， type_name是要转换的类型名称
要将类转换为其他类型，需要创建类成员函数：
operator type_name ( )； // type_name 为要转换的类型
使用转换函数时要小心，可以在声明构造函数时使用关键字 explicit，防止被用于隐式转换
其构造函数使用 new 的类
如果使用 new 运算符来分配类成员指向的内存，在设计时应采取一些措施：
- 对于指向的内存是由 new 分配的所有类成员，都应在析构函数中对其使用 delete，该运算符将释放分配的内存；
- 如果析构函数通过对指针类成员使用 delete 来释放内存，则每个构造函数都应当使用 new 来初始化指针，或设置为空指针；
- 构造函数使用 new[ ] 或 new，不能混用；
- new [ ] 对应于 delete [ ] ， new 对应于 delete；
- 应定义一个分配内存（而不是使用指针指向已有内存）的复制构造函数。这样程序能将类对象初始化为另一个类对象；
- 应定义一个重载赋值运算符的类成员函数，这样程序能将类对象赋值给另一个类对象
//queue.h -- interface for a queue
#ifndef QUEUE_H_
#define QUEUE_H_
//This queue will contain Customer items
class Customer
{
private:
long arrive; //arrival time for customer
int processtime; //processing time for customer
public:
Customer(){
arrive = processtime = 0;
}
void set(long when);
long when() const {
return arrive;
}
int ptime() const {
return processtime;
}
};
typedef Customer Item;
class Queue{
private:
struct Node
{
Item item;
Node* next;
};
enum
{
Q_SIZE = 10
};
Node * front; //pointer to front of Queue
Node * rear; //pointer to rear of Queue
int items;
const int qsize; //maximum number of items in Queue
Queue(const Queue& q) :qsize(0){}
Queue& operator=(const Queue & q){
return *this;
}
public:
Queue(int qs = Q_SIZE); //create queue with a qs limit
~Queue();
bool isEmpty() const;
bool isFull() const;
int queuecount() const;
bool enQueue(const Item& item);
bool deQueue(Item& item);
};
#endif // !QUEUE_H_
//queue.cpp
#include "queue.h"
#include // bank.cpp -- using the Queue interface
// compile with queue.cpp
#include