2. 程式人生 > >C++基礎學習之類和動態記憶體分配(9)

C++基礎學習之類和動態記憶體分配(9)

阿新 • • 發佈：2018-11-12

主要學習內容：

  • 對類成員使用動態記憶體分配。
  • 隱式顯式複製建構函式。
  • 隱式顯式過載賦值運算子。
  • 在建構函式中使用new所必須完成的工作。
  • 使用靜態類成員。
  • 將定位new運算子用於物件。
  • 使用指向物件的指標。
  • 實現佇列抽象資料型別。（像第（7）篇中的stack實現一樣）

動態記憶體和類

首先說一下類中的靜態類成員。類似如下宣告：

class StringBad
{
private:
	char * str;
	int len;
	static int num_strings;		// 靜態類成員
public:
...
}

靜態類成員有一個特點：無論建立了多少物件，程式都只建立一個靜態類變數副本。也就是說，類的所有物件共享同一個靜態成員。所以上面定義的num_strings成員可以記錄所建立的物件數目。另外，靜態類成員在類宣告中宣告，但需要在類宣告之外使用單獨的語句進行初始化。初始化的形式如下：

// initializing static class member
int StringBad::num_strings = 0;

然後就說一下隱式顯式的建構函式，C++會自動提供下面這些成員函式：

  • 預設建構函式，如果沒有定義建構函式；
  • 預設解構函式，如果沒有定義；
  • 複製建構函式，如果沒有定義；
  • 賦值運算子，如果沒有定義；
  • 地址運算子，如果沒有定義。

最後一個先不討論，這就說明了如果自己沒有定義上面這些函式，那麼C++會自己生成這些函式，但是當使用對應的類方法時，這些自動生成的函式卻不一定會是我們想要的方法。由此就會帶來一些錯誤。接下來說一下這些成員函式以及它們被呼叫的一些情況。

  1. 預設建構函式
    如果沒有提供任何建構函式，C++就會建立一個空建構函式。例如，假如定義了一個Klunk類，但沒有提供任何建構函式，則編譯器將提供下面的建構函式：
    Klunk::Klunk() {} 	//implicit default constructor
    這種建構函式會在建立物件是呼叫，最好自己定義一個建構函式來初始化類。
  2. 複製建構函式
    複製建構函式用於將一個物件複製到新建立的物件中。也就是說，它用於初始化過程中（包括按值傳遞引數），而不是常規的賦值過程中。類的複製建構函式原型通常如下：
    Class_name(const Class_name &);
    例如：
    StringBad(const StingBad &);
    新建一個物件並將其初始化為同類現有物件時，複製建構函式都將被呼叫。最常見的情況時將新物件顯式地初始化為現有的物件。下面4種宣告都將呼叫複製建構函式：
    StringBad ditto(motto);	// calls StringBad(const StringBad &)
StringBad metoo = motto;	// calls StringBad(const StringBad &)
StringBad also = StringBad(motto);	// calls StringBad(const StringBad &)
StringBad * pStringBad = new StringBad(motto);	// calls StringBad(const StringBad &)
    其中中間的2種宣告可能會使用複製建構函式直接建立metoo和also，也可能使用複製建構函式生成一個臨時物件，然後將臨時物件的內容賦給metoo和also，這取決於具體的實現。最後一種宣告使用motto初始化一個匿名物件，並將新物件的地址賦給pstring指標。每當程式生成了物件副本時，編譯器都將使用複製建構函式。具體的說，當函式按值傳遞物件或函式返回物件時，都將使用複製建構函式。因為按值傳遞意味著建立原始變數的一個副本。而編譯器生成臨時物件時，也將使用複製建構函式。
    預設的複製建構函式只會逐個複製非靜態成員（成員複製葉稱為淺複製），複製的是成員的值。所以也應該定義一個顯式的複製建構函式防止出現問題。
  3. 賦值運算子
    當使用賦值運算子時，預設的賦值運算子函式也是隻進行淺複製，所以如果類成員中有指標的話會直接給指標賦值，這樣兩個類物件內的類成員指標指向同一塊記憶體，一旦釋放其中一個類，那麼這塊記憶體就會被釋放，會造成記憶體洩漏。
    解決問題的方法就是自己重新定義賦值運算子函式：
    StringBad & StringBad::operator=(const StringBad & st)
{
	if (this == &st)
		return *this;
	delete [] str;		// free old string
	len = st.len;
	str = new char [len+1];		// get space for new string
	std::strcpy(str, st.str);		// copy the string
	return *this;
}
    len+1是因為len方法或者strlen函式都是隻計算字串長度，不計算最後一個空字元\0，所以要加這個空字元的空間。

構造一個String類

這個類是仿照C++的string寫的一個類，一方面可以鞏固和練習之前的知識，另一方面可以瞭解一個string類的實現方法。

// string1.h -- fixed and augmented string class definition
#ifndef STRING1_H_
#define STRING1_H_
#include <iostream>
using std::ostream;
using std::istream;

class String
{
private:
	char * str;		// pointer to string
	int len;		// length of string
	static int num_strings;	// number of objects
	static const int CINLIM = 80;	// cin input limit
public:
// constructors and other methods
	String(const char * s);	// constructor
	String();				//default constructor
	String(const String &);	// copy constructor
	~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);
// static function
	static int HowMany();
}
#endif

方法定義：

// string1.cpp -- String class method
#include <cstring>		// string.h for some
#include "string1.h"	// includes <iostream>
using std::cin;
using std::cout;

//intializing 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_strings++;
}

String::String()					// default constructor
{
	len = 4;
	str = new char[1];
	str[0] = '\0';
	num_strings++;
}

String::String(const Stirng & st)
{
	num_strings++;				// 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
}

String::~String()
{
	--num_strings;
	delete [] str;
}

// 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;
}
// 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==(const 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>>(ostream & is, String & st)
{
	char temp[String::CINLIM];
	is.get(temp, String::CINLIM);
	if (is)
		st = temp;
	while (is && is.get() != '\n')
		continue;
	return is;
}

建構函式中使用new的注意事項

使用new初始化物件的指標成員時應該這樣做：

  • 如果在建構函式中使用new來初始化指標成員，則應在解構函式中使用delete。
  • new和delete必須相互相容。new對應於delete，new[]對應於delete[]。
  • 如果有多個建構函式，則必須以相同的方式使用new，要麼都帶中括號，要麼都不帶。因為只有一個解構函式，所有的建構函式都必須與它相容。
  • 應定義一個複製建構函式，通過深度複製將一個物件初始化為另一個物件。
  • 應定義一個賦值運算子，通過深度複製將一個物件複製給另一個物件。
    具體的說，該方法應完成這些操作：檢查自我賦值的情況，釋放成員指標以前指向的記憶體，複製資料而不僅僅是資料的地址，並返回一個指向呼叫物件的引用。

有關返回物件的說明

當成員函式或獨立的函式返回物件時，有三種返回方式：返回指向物件的引用、返回指向物件的const引用或返回const物件。

  1. 返回指向const物件的引用
    最好如下編寫函式：
const Vector & Max(const Vector & v1, const Vector & v2)
{
	if (v1.magval() > v2.magval())
		return v1;
	else
		return v2;
}
  1. 返回指向非const物件的引用
    兩種常見的返回非const物件情形是過載運算子以及過載與cout一起使用的<<運算子。前者為了效率，後者必須要這麼做。所以這兩種情況也返回引用。
  2. 返回物件
    如果被返回物件是被調函式中的區域性變數，則不應該按引用方式返回它，因為在被調函式執行完畢時，區域性物件將呼叫其解構函式。因此，當控制權回到呼叫函式時，引用指向的物件將不再存在。在這種情況下，應返回物件而不是引用。通常，被過載的算術運算子屬於這一類。
  3. 返回const 物件
    在上面的那種情況中如果擔心一些誤操作會將返回的物件值改變，則應該返回const物件。

使用指向物件的指標

使用new初始化物件：
通常，如果Class_name是類，value的型別為Type_name，則下面的語句：
Class_name * pclass = new Class_name(value);
將呼叫如下建構函式：
Class_name (const Type_name &);
另外，如果不存在二義性，則將發生由原型匹配導致的轉換（如從int到double）。下面的初始化方式將呼叫預設建構函式：
Class_name * ptr = new Class_name;
如果使用如下語句來建立物件：
String * favorite = new String(sayings[choice]);
這裡使用new來為整個物件分配記憶體，之後如果不再需要該物件就用delete刪除：
delete favorite;
這裡的釋放只是釋放儲存這個物件的指標，使用這句話後會自動呼叫解構函式來釋放物件的內容。
另外指向物件的指標可以使用->運算子來訪問類方法，也可以對物件指標應用運算子（*）來獲得物件。（也就是說和基本標準變數指標一樣的用法）。

佇列模擬（queue）

queue.h

// 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 = precesstime = 0; }
	
	void set(long when);
	long when() const { return arrive; }
	int ptime() const { return processtime; }
};

typedef Customer Item;

class Queue
{
private:
// class scope definitions
	// Node is a nested structure definition local to this c
	struct Node { Item item; struct Node * next;};
	enum {Q_SIZE = 10};
// private class members
	Node * front;	// pointer to front of Queue
	Node * rear;	// pointer to rear of Queue
	int items;	// current number of items in Queue
	const int qsize;	// maximum number of items in Queue
	// preemptive definitions to prevent public copying
	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);	// add item to end
	bool dequeue(Item &item);		// remove item from front
}
#endif

queue.cpp

// queue.cpp -- Queue and Customer methods
#include "queue.h"
#include <cstdlib>		// (or stdlib.h) for rand()

// Queue methods
Queue::Queue(int qs) : qsize(qs)
{
	front = rear = NULL;	// or nullptr
	items = 0;
}

Queue::~Queue()
{
	Node * temp;
	while (front != NULL)	// while queue is not yet empty
	{
		temp = front;	// save address of front item
		front = front->next;	// reset pointer to next item
		delete temp;	// delete former front
	}
}

bool Queue::isempty() const
{
	return items == 0;
}
bool Queue::isfull() const
{
	return items == qsize;
}

int Queue::queuecount() const
{
	return items;
}

// Add item to queue
bool Queue::enqueue(const Item & item)
{
	if (isfull())
		return false;
	Node * add = new Node;	// create node
// on failure, new throws std::bad_alloc exception
	add->item = item;	// set node pointers
	add->next = NULL;	// or nullptr
	items++;
	if (front == NULL)	// if queue is empty,
		front = add;	// place item at front
	else
		rear->next = add;	// else place at rear
	rear = add;		// have rear point to new node
	return true;
}

// Place front item into item variable and remove from queue
bool Queue::dequeue(Item & item)
{
	if (front == NULL)
		return false;
	item = front->item;		// set item to first item in queue
	items--;
	Node * temp = front;	//save location of first item
	front = front->next;	// reset front to next item
	delete temp;		// delete former first item
	if (items == 0)
		rear = NULL;
	return true;
}
// time set to a random value in the range 1 - 3
void Customer::set(long when)
{
	processtime = std::rand() % 3 + 1;
	arrive = when;
}

這個程式中涉及到的一些點：

  1. 巢狀結構和類
    在類宣告中宣告的結構、類或列舉被稱為是被巢狀在類中，其作用域為整個類。這種宣告不會建立資料物件，而只是指定了可以在類中使用的型別。如果宣告是在類的私有部分進行的，則只能在這個類中使用被宣告的型別；如果宣告是在公有部分進行的，則可以從類的外部通過作用域解析運算子使用被宣告的型別。例如，如果Node是在Queue類的公有部分宣告的，則可以在類的外面宣告Queue::Node型別的變數。
  2. 成員初始化列表
    成員初始化列表是C++提供的一種特殊語法，用來對於const資料成員在執行到建構函式體之前，即建立物件時進行初始化。成員初始化列表由逗號分隔的初始化列表組成（前面帶冒號）。它位於引數列表的右括號之後、函式體左括號之前。例如：
    Queue:: Queue(int qs) : qsize(qs)	// initialize qsize to qs
{
	front = raer = NULL;
	items = 0;
}
    通常，初值可以是常量或建構函式的引數列表中的引數。但這種方法並不限於初始化常量。例如：
    Queue:: Queue(int qs) : qsize(qs), front(NULL), rear(NULL), items(0)
{
}
    只有建構函式可使用這種初始化列表語法。對於const類成員，必須使用這種語法。另外，對於被宣告為引用的類成員，也必須使用這種語法：
    class Agency {...};
calss Agent
{
private:
	Agency & belong;	// must use initializer list to initialize
	...
};
Agent::Agent(Agency & a) : belong(a) {...}
    因為引用和const資料類似，只能在被建立時進行初始化。對於簡單資料成員，使用成員初始化列表和在函式體種使用賦值沒有什麼區別。然而，對於本身就是類物件的類成員來說，使用成員初始化列表的效率更高。
  3. C++11的類內初始化
    C++11種可以使用更加直觀的方式進行初始化：
    class Classy
{
	int mem1 = 10;		// in-class initialization
	const int mem2 = 20;	// in-class initialization
//...
};
    這與在建構函式中使用成員初始化列表等價：
    Classy::Classy() : mem1(10), mem2(20) {…}
    成員mem1和mem2將分別被初始化為10和20，除非呼叫了使用成員初始化列表的建構函式，在這種情況下，實際列表將覆蓋這些預設初始值：
    Classy::Classy(int n) : mem1(n) {…}
    在這裡，建構函式將使用n來初始化mem1，但mem2仍被設定為20。

相關推薦

C++基礎學習之類和動態記憶體分配(9)

主要學習內容： 對類成員使用動態記憶體分配。 隱式顯式複製建構函式。 隱式顯式過載賦值運算子。 在建構函式中使用new所必須完成的工作。 使用靜態類成員。 將定位new運算子用於物件。 使用指向物件的指標。 實現佇列抽象資料型別。（像第（

C++PrimerPlus學習之類和動態記憶體分配

複製建構函式 如果沒有定義，編譯器將預設提供複製建構函式 原型Class_name(const Class_name &) StringBad(const StringBad &) 何時呼叫StringBad ditto(motto); Str

c語言基礎（六）靜態和動態記憶體分配

1.靜態記憶體是程式編譯執行後系統自動分配，由系統自動釋放，靜態記憶體是棧分配的 第一次執行完畢後i就被釋放了，所以後面輸出的為垃圾值 2.動態記憶體分配是開發者手動分配的，是堆分配的 malloc（int）函式申請記憶體空間 free（）回收 realloc（）重新分

C語言的儲存類別和動態記憶體分配

儲存類別分三大類： 靜態儲存類別 自動儲存類別 動態分配記憶體   變數、物件--->記憶體管理 記憶體考慮效率（時間更短、空間更小） 作用域 連結、---->空間 儲存器   ----->時間   其實儲存類別（時間、空間）和資料

類和動態記憶體分配（C++）

動態記憶體和類： C++使用new和delete運算子來動態控制記憶體。C++在分配記憶體時採取的是：讓程式在執行時決定記憶體分配，而不是在編譯時決定。 首先，我們先構造一個只有字串、字串長度和字串個數的類： #pragma once #include<i

C++ Primer Plus（第六版）程式設計練習答案 第12章 類和動態記憶體分配

本章所有程式設計練習的工程原始碼可在此處下載（點選此連結下載），供大家參考交流！ 1. 對於下面的類宣告： class Cow {          char name[20];          char *hobby;          double wei

C++Primer Plus筆記——第十二章 類和動態記憶體分配總結及程式清單

目錄 本章小結 程式清單 本章小結        本章介紹了定義和使用類的許多重要方面。其中的一些方面是非常微妙甚至很難理解的概念。如果其中的某些概念對於您來說過於複雜，也不用害怕——這些問題對於大多數C++的初學者來說都是很難的。 通常，對於諸如複製

C++Primer Plus筆記——第十二章 類和動態記憶體分配課後程式設計練習答案

目錄 課後習題 習題1 習題2 習題3 習題4 習題5&6 課後習題 習題1 #include <iostream> #include <cstring> using namespace std; class Cow {

C++之繼承和動態記憶體分配

        接下來看複製建構函式，預設複製建構函式執行成員複製，這對於動態記憶體分配來說是不合適的，但對於派生類成員來說是合適的，因此只需要考慮繼承的基類物件，成員複製將根據資料型別採用相應的複製方式，複製類成員或者整合的類元件的時候，則是使用該類的複製建構函式完成的。所以，派生類的預設複製建構函式使用顯

c++類和動態記憶體分配

動態記憶體和類 特殊成員函式 1預設建構函式，如果你沒有定義建構函式 2預設的解構函式，如果你沒有定義解構函式 3複製建構函式，如果你沒有定義 4賦值運算子，如果你沒有定義 5地址運算子，如果你妹你沒有定義 1，2我們已經說說了，現在我們來說說後面的 何時呼叫複製建構函式

C++回爐之_C++PrimerPlus_第十二章 類和動態記憶體分配

複製建構函式 如果沒有定義複製建構函式 – C++會自動提供 原型 class_name(const class_name&); Point(const Point&); 功能

C語言動態記憶體管理和動態記憶體分配

動態記憶體管理同時還具有一個優點：當程式在具有更多記憶體的系統上需要處理更多資料時，不需要重寫程式。標準庫提供以下四個函式用於動態

c++：為什麼要使用動態記憶體分配

例項化一個類有兩種方式： // 假設有一個類A // 方式一：直接定義法 A a; // 方式二：動態記憶體分配法 A * a = new A(); 兩者有什麼差別呢？ 實際上，方式二即等價於如下程式碼： A * a = new A(); 等價於 A * a; a = n

C++基礎學習之類繼承(10)

面向物件程式設計的主要目的之一是提供可重用的程式碼。C++提供了更高層次的重用性方法來擴充套件和修改類。這種方法叫類繼承，它能夠從已有的類派生出新的類，而派生類繼承了原有類（稱為基類）的特徵，包括方法。通過繼承可完成的工作有： 可以在已有類的基礎上新增功能。例如，對於陣列類，可以

類和動態記憶體分配（3）

定位new運算子號 //main.cpp #include<iostream> #include<string> using namespace std; const int BUF = 512; class JustTest { private: stri

類和動態記憶體分配（2）

·## 改進後的StringBad類： //stringbad.h #include <iostream> #ifndef STRINGBAD_H_ #define STRINGBAD_H_ class StringBad { private : char *str;

類和動態記憶體分配（1）

假設我們要建立一個類，其中有一個成員表示某人的姓，最簡單的就是用字串陣列來儲存，開始使用14個字元的陣列，發現太小，保險的方法是使用40個字元的陣列，但是當建立2000多個這個樣的物件時，必定會造成記憶體浪費。通常使用string類，該類有良好的記憶體管理細節。但是這樣就沒有機會深入的學習記

【6】C++進階系列（動態記憶體分配）

問題：之前在寫程式的時候計劃好我們需要哪些資料，都定義好，但是有些時候我們並不知道我要處理的程式規模有多大，也不知道陣列開多大合適，是儘量大？分配了太大空間可能會造成記憶體的浪費。只有在程式真正執行起來才會知道這次執行要處理的資料規模有多大——那就有人想，能不能用變數來確定陣

類和動態記憶體分配雜談

看了《C++ Primer Plus》第十二章，總結一下就是，自己的物件要有自己的記憶體，別老想著共享一段記憶體，以避免造成不必要的後序麻煩。尤其是使用new時，應該堅持一new對應一delete，有的時候雖然不是那麼必要，但是還是那句話，避免一些么蛾子。程式設計也就跟做行政

C++基礎學習筆記：類與動態記憶體分配

實現一個簡單的string類 user.h //!時間：2017年9月11日（週一）上午 //!內容：類與動態記憶體分配 //!備註：Test類實現簡單的string功能 //!最後修改時間：NULL //user.cpp #define _CRTDBG_MAP_ALLOC//記憶體