C++ 类和动态内存分配(学习笔记)
示例代码(来自C++PrimerPlus)
文件中所有的英文的注释都是来自于书本的内容。
// string1.h -- fixed and augmented string class definition
// 这个文件用来描述一个自己定义的字符串类,.h 头文件中经常保存类、函数等的定义信息,
// 并在包含了该头文件的.cpp文件中得到实现。
#ifndef STRING1_H_
#define STRING1_H_
// 预编译过程中,如果发现程序定义过 STRING1_H_,
// 说明其中的内容已经被包含,重复包含同样的内容无法通过编译
// 所以通过 #ifndef #define #endif 确保中间的内容不会被重复引用。
#include <iostream>
using std::ostream;
using std::istream;
// 通过 using 引用的命名空间,特别指出要使用的名称而不是直接引用全部,
// 比如 std::ostream 而不是 std 在一些复杂的情况中很有帮助
class String
{
private:
char* str; // pointer to string
int len; // length of string
// String 类中保存了字符串的首地址 str,并为其动态地分配内存空间
// 当字符串内容改变时,长度(所占内存)随之改变,记录在 len 中,
// 虽然 len 占据了空间,但能避免频繁的使用带来的每一次都要计算的开销。
static int num_strings; // number of objects
static const int CINLIM = 80; // cin input limit
// static 关键字表明 num_strings 和 CIMLIM 两个 int 型变量是静态的。
// 即不管今后创建了多少个 String 的对象,这两个变量只有一份,所有的 String 共用
public:
// constructors and other methods
String(const char* s); // constructor
// 该构造函数同时可以作用于变量的类型转变,当需要一个 String 变量,
// 而得到的输入是 char* 时,将通过这个构造函数自动的进行变量类型转换。
String(); // default constructor
// 没有任何形参的构造函数是默认构造函数,即使没有定义它,编译器也会自动生成
// 但对于 String 类,如果是一个对象创建时使用的是自动生成的默认构造函数,它将不会通过 new 来动态的分配空间
// 而在使用完毕调用析构函数时会使用 delete[] 关键字来释放 str 所占据的空间,这时会产生错误,因此必须要手动定义默认构造函数
String(const String &); // copy constructor
// 复制构造函数如果没有被定义也会由编译器自动生成,但时常不会尽如人意,
// 因为我们的 String 类有计数的功能,默认的复制构造函数不会增加它的数量统计
~String(); // destructor
int length() const { return len; }
// overloaded operator methods
String & operator=(const String &);
String & operator=(const char *);
char & operator[](int i);
const char& operator[](int i) const;
// overloaded operator friends
friend bool operator<(const String& st, const String &st2);
friend bool operator>(const String &st1, const String &st2);
friend bool operator==(const String &st, const String &st2);
friend ostream & operator<<(ostream & os, const String & st);
friend istream & operator>>(istream & is, String & st);
// 这里把返回值设置为 ostream 和 istream 而不是 void 是很有必要的
// 比如使用 cout<< 时经常这样 cout<<1<<str<<endl; 这要求 cout << 1 运行后返回值仍然是 cout
// static int HowMany();
};
#endif
// string1.cpp -- String class methods
#include <cstring> // string.h for some
#include "string1.h" // includes <iostream>
using std::cin;
using std::cout;
// initializing static class member
int String::num_strings = 0;
// static method
int String::HowMany()
{
return num_strings;
}
// class methods
String::String(const char * s) // construct String from C string
{
len = std::strlen(s); // set size
str = new char[len + 1] // allot storage
std::strcpy(str, s); // initialize pointer
num_string++; // set object count
}
String::String() // default constructor
{
len = 4;
str = new char[1];
str[0] = '\0'; // default String
num_string++;
}
String::String(const String & st)
{
num_string++; // handle static member update
len = st.len; // same length
str = new char [len + 1]; // allot space
std::strcpy(str, st.str); // copy string to new location
}
// 复制构造函数,要求输入参数仍是本身的数据类型
// 在复制的时候采用复制字符串str里存储的所有字符的方式而不是单纯的复制这个指针
// 这种复制构造函数被称做深拷贝,如果只是复制了指针的地址的话,将会导致
// 几个保存了相同的字符串的 String,当其中一个被销毁时,字符串所占据的空间就已经被释放了,
// 如果其他几个 String 再释放空间就会产生问题
// 而且这也不符合面向对象的封装保护的思想。
String::~String() // necessary destructor
{
--num_strings; // required
delete [] str; // required
}
// overloaded operator methods
// assign a String to a String
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;
}
// assign a C string to a String
String & String::operator=(const char* s)
{
delete [] str;
len = std::strlen(s);
str = new char[len + 1];
std::strcpy(str, s);
return *this;
}
// read write char access for non_const String
char & String::operator[](int i)
{
return str[i];
}
// read-only char access for const String
const char & String::operator[](int i) const
{
return str[i];
}
// overloaded operator friends
bool operator<(const String &st1, const String &st2)
{
return (std::strcmp(st1.str, st2.str) < 0);
}
bool operator>(const String &st1, const String &st2)
{
return st2 < st1;
}
bool operator==(cosnt String &st1, const String &st2)
{
return (std::strcmp(st1.str, st2.str) == 0);
}
// simple String output
ostream & operator<<(ostream & os, const String & st)
{
os << st.str;
return os;
}
// quick and dirty String input
istream & operator>>(istream & is, String & st)
{
char temp[String::CINLIM];
is.get(temp, String::CINLIM];
if (is)
st = temp;
while (is && is.get() != '\n')
continue;
return is;
}