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

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

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

目錄

本章小結

程式清單

本章小結

       本章介紹了定義和使用類的許多重要方面。其中的一些方面是非常微妙甚至很難理解的概念。如果其中的某些概念對於您來說過於複雜，也不用害怕——這些問題對於大多數C++的初學者來說都是很難的。 通常，對於諸如複製建構函式等概念，都是在由於忽略它們時遇到了麻煩後逐步理解的。本章介紹的一些內容乍看起來非常難以理解，但是隨著經驗越來越豐富，對其理解也將越透徹。

       在類建構函式中，可以使用new為資料分配記憶體，然後將記憶體地址賦給類成員。這樣，類便可以處理長度不同的字串，而不用在類設計時提前固定陣列的長度。在類建構函式中使用new，也可能在物件過期時引發問題。如果物件包含成員指標，同時它指向的記憶體是由new分配的.則釋放用於儲存物件的記憶體並不會自動釋放物件成員指標指向的記憶體。因此在類建構函式中使用new類來分配記憶體時，應在類解構函式中使用delete來釋放分配的記憶體。這樣，當物件過期時，將自動釋放其指標成員指向的記憶體。

       如果物件包含指向new分配的記憶體的指標成員，則將一個物件初始化為另—個物件，或將一個物件賦給另一個物件時，也會出現問題。在預設情況下，C++逐個對成員進行初始化和賦值，這意味著被初始化或被賦值的物件的成員將與原始物件完全相同。如果原始物件的成員指向一個數據塊，則副本成員將指向同一個資料塊。當程式最終刪除這兩個物件時，類的解構函式將試圖刪除同一個記憶體資料塊兩次，這將出錯。解決方法是：定義一個特殊的複製建構函式來重新定義初始化，並重載賦值運擇符。在上述任何一種 情況下，新的定義都將建立指向資料的副本，並使新物件指向這些副本。這樣，舊物件和新物件都將引用獨立的、相同的資料而不會重疊。由於同樣的原因，必須定義賦值運算子。對於每一種情況，最終目的都是執行深度複製，也就是說，複製實際的數裾，:而不僅僅是複製指向資料的指標。

       物件的儲存持續性為自動或外部時，在它不再存在時將自動呼叫其解構函式。如使用new運算子為物件分配記憶體，並將其地址賦賦給一個指標，則當您將delete用於該指標時將自動為物件呼叫解構函式。然而，如果使用定位new運算子(而不是常規new運算子) 為類物件分配記憶體，則必須負責顯式地為該物件呼叫解構函式，方法是使用指向該物件的指標呼叫解構函式方法。C++允許在類中包含結構、類和列舉定義。這些巢狀型別的作用域是整個類，這意味著它們被侷限於類中，不會與其他地方定義的同名結構、類和枚舉發生衝突。

       C++為類建構函式提供了一種可用來初始化資料成員的特殊語法。這種語法包括冒號和由逗號分隔的初始化列表，被放在建構函式引數的右括號後，函式體的左括號前。每一個初始化器都由被初始化的成員的名稱和包含初值的括號組成。從概念上說，這些初始化操作是在物件建立時進行的，此時函式體中的語句還沒有執行。語法如下;

       queue(int qs) :qsize(qs),items(0),front(NULL),rear(NULL) {}

       如果資料成員是非靜態const成員或引用，則必須採用這種格式，但可將C++11新增類內初始化用於非靜態const成員。

       C++允許類內初始化，即在類定義中進行初始化：

class Queue
{
private:
...
    Node * front = NULL;
    enum {Q_SIZE = 10};
    int items = 0;
    const int qsize = Q_SIZE;
...
}

       這與使用初始化列表等價。然而，使用成員初始化列表的建構函式將覆蓋相應的類內初始化。

程式清單

改進前的string類（在建構函式和解構函式中使用了動態記憶體分配）

12.1 strngbad.h 

//strngbad.h -- flawed string class definition

#include <iostream>

#ifndef STRNGBAD_H_
#define STRNGBAD_H_

class StringBad
{
private:
	char * str;
	int len;
	static int num_strings;
public:
	StringBad(const char *s);
	StringBad();
	~StringBad();
	friend std::ostream & operator << (std::ostream & os, const StringBad & st);
};

#endif // !STRNFBAD_H_

12.2 strngbad.cpp

//strngbad.cpp -- StringBad calss methods
#include <cstring>
#include "strngbad.h"

using namespace std;

int StringBad::num_strings = 0;

StringBad::StringBad(const char *s)
{
	len = strlen(s);
	str = new char[len + 1];
	strcpy(str, s);
	num_strings++;
	cout << num_strings << ": \"" << str << "\" object created\n";
}

StringBad::StringBad()
{
	len = 4;
	str = new char[4];
	strcpy(str, "C++");
	num_strings++;
	cout << num_strings << ": \"" << str << "\" default object created\n";
}

StringBad::~StringBad()
{
	cout << "\"" << str << "\" object deleted\n";
	--num_strings;
	cout << num_strings << " left\n";
	delete[]str;
}

ostream & operator << (ostream & os, const StringBad &st)
{
	os << st.str;
	return os;
	return os;
}

12.3 vegnews.cpp

//vegnews.cpp -- using new and delete with classes 
//compile with strngbad.cpp
#include <iostream>
#include "strngbad.h"

using namespace std;

void callme1(StringBad &);
void callme2(StringBad);

int main()
{
	cout << "Startings an inner block.\n";
	StringBad headline1("Celery Stalks at Midnight");
	StringBad headline2("Lettuce Prey");
	StringBad sports("Spinach Leaves Bowl for Dollars");

	cout << "headline1: " << headline1 << endl;
	cout << "headline2: " << headline2 << endl;
	cout << "sports: " << sports << endl;
	callme1(headline1);
	cout << "headline1: " << headline1 << endl;
	callme2(headline2);
	cout << "headline1: " << headline1 << endl;
	cout << "Initialize one object to another:\n";
	StringBad sailor = sports;
	cout << "sailor: " << sailor << endl;
	cout << "Assign one object to another:\n";
	StringBad knot;
	knot = headline1;
	cout << "knot: " << knot << endl;
	cout << "Exiting the block.\n";
	cout << "End of main()\n";

	return 0;
}

void callme1(StringBad & rsb)
{
	cout << "String passed by reference:\n";
	cout << "    \"" << rsb << "\"\n";
}

void callme1(StringBad & sb)
{
	cout << "String passed by value:\n";
	cout << "    \"" << sb << "\"\n";
}

改進後的String類（添加了複製建構函式及賦值運算子）

12.4 string1.h

//string1.h -- fixed and augmented string class definition
#ifndef STRING1_H_
#define STRING1_H_

#include <iostream>

using namespace std;

class String
{
private:
	char * str;
	int len;
	static int num_strings;
	static const int CINLIM = 80;
public:
	String(const char * s);
	String();
	String(const String &);
	~String();
	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 &st, 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_H_

12.5 string1.cpp

//string1.cpp -- String class methods
#include <cstring>
#include "string1.h"

using namespace std;

int String::num_strings = 0;

int String::HowMany()
{
	return num_strings;
}

String::String(const char * s)
{
	len = strlen(s);
	str = new char[len + 1];
	strcpy(str, s);
	num_strings++;
}

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

String::String(const String & st)
{
	num_strings++;
	len = st.len;
	str = new char[len + 1];
	strcpy(str, st.str);
}

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

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

String & String::operator=(const char * s)
{
	delete[]str;
	len = strlen(s);
	str = new char[len + 1];
	strcpy(str, s);
	return *this;
}

char & String::operator[](int i)
{
	return str[i];
}

const char & String::operator[](int i) const
{
	return str[i];
}

bool operator<(const String &st1, const String &st2)
{
	return (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 (strcmp(st1.str, st2.str) == 0);
}

ostream & operator<<(ostream & os, const String & st)
{
	os << st.str;
	return os;
}

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;
}

12.6 sayings1.cpp

//sayings1.cpp -- using expanded String class
//compile with string1.cpp

#include <iostream>
#include "string1.h"

const int ArSize = 10;
const int MaxLen = 81;

int main()
{
	using namespace std;

	String name;
	cout << "Hi, what's your name?\n>> ";
	cin >> name;

	cout << name << ", please enter up to " << ArSize << " short saying <empty line to quit>:\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')
			break;
		else
			sayings[i] = temp;
	}
	int total = i;

	if (total > 0)
	{
		cout << "Here are your sayings:\n";
		for (i = 0; i < total; i++)
			cout << sayings[i][0] << ": " << sayings[i] << endl;

		int shortest = 0;
		int first = 0;
		for (i = 1; i < total; i++)
		{
			if (sayings[i].length() < sayings[shortest].length())
				shortest = i;
			if (sayings[i] < sayings[first])
				first = i;
		}
		cout << "Shortest saying:\n" << sayings[shortest] << 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;
}

12.7 sayings2.cpp  使用指標追蹤新物件

//sayings2.cpp -- using pointers to objects
//compile with string1.cpp
#include <iostream>
#include <cstdlib>
#include <ctime>
#include "string1.h"

const int ArSize = 10;
const int MaxLen = 81;

int main()
{
	using namespace std;
	String name;
	cout << "Hi, what's your name?\n>> ";
	cin >> name;

	cout << name << ", please enter up to " << ArSize << " short saying <empty line to quit>:\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')
			break;
		else
			sayings[i] = temp;
	}
	int total = i;

	if (total > 0)
	{
		cout << "Here are your sayings:\n";
		for (i = 0; i < total; i++)
			cout << sayings[i] << endl;

		String * shortest = &sayings[0];
		String * first = &sayings[0];
		for (i = 1; i < total; i++)
		{
			if (sayings[i].length() < shortest->length())
				shortest = &sayings[i];
			if (sayings[i] < *first)
				first = &sayings[i];
		}
		cout << "Shortest saying:\n" << *shortest << endl;
		cout << "First alphabetically:\n" << *first << endl;
		srand(time(0));
		int choice = rand() % total;
		String * favorite = new String(sayings[choice]);
		cout << "My favorite saying:\n" << *favorite << endl;
		delete favorite;
	}
	else
		cout << "Not much to say, eh?\n";
	cout << "Bye.\n";
	return 0;
}

再談定位new運算子

12.8 placenew1.cpp 定位new運算子

//placenew1.cpp -- new, placement new, no delete
#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];

	JustTesting *pc1, *pc2;

	pc1 = new (buffer) JustTesting;
	pc2 = new JustTesting("Heap1", 20);

	cout << "Memory block address:\n" << "buffer: " << (void *)buffer << "  heap: " << pc2 << endl;
	cout << "Memory contents: \n";
	cout << pc1 << ": ";
	pc1->Show();
	cout << pc2 << ": ";
	pc2->Show();

	JustTesting *pc3, *pc4;
	pc3 = new(buffer) JustTesting("Bad Idea", 6);
	pc4 = new JustTesting("Heap2", 10);

	cout << "Memory contents:\n";
	cout << pc3 << ": ";
	pc3->Show();
	cout << pc4 << ": ";
	pc4->Show();

	delete pc2;
	delete pc4;
	delete[] buffer;
	cout << "Done\n";
	return 0;
}

12.9 placenew2.cpp 加入了合適的delete和顯式解構函式

//placenew2.cpp -- new, placement new, no delete
#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];

	JustTesting *pc1, *pc2;

	pc1 = new (buffer) JustTesting;
	pc2 = new JustTesting("Heap1", 20);

	cout << "Memory block address:\n" << "buffer: " << (void *)buffer << "  heap: " << pc2 << endl;
	cout << "Memory contents: \n";
	cout << pc1 << ": ";
	pc1->Show();
	cout << pc2 << ": ";
	pc2->Show();

	JustTesting *pc3, *pc4;
	pc3 = new(buffer + sizeof(JustTesting)) JustTesting("Better Idea", 6);
	pc4 = new JustTesting("Heap2", 10);

	cout << "Memory contents:\n";
	cout << pc3 << ": ";
	pc3->Show();
	cout << pc4 << ": ";
	pc4->Show();

	delete pc2;
	delete pc4;
	pc3->~JustTesting();
	pc1->~JustTesting();
	delete[] buffer;
	cout << "Done\n";
	return 0;
}

複習：模擬佇列

12.10 queue.h

//queue.h -- interface for a queue
#ifndef QUEUE_H_
#define QUEUE_H_

class Customer
{
private:
	long arrive;
	int processtime;
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; struct Node * next; };
	enum { Q_SIZE = 10 };
	Node * front;
	Node * rear;
	int items;
	const int qsize;
	Queue(const Queue & q) : qsize(0) {}
	Queue & operator=(const Queue & q) { return *this; }
public:
	Queue(int qs = Q_SIZE);
	~Queue();
	bool isempty() const;
	bool isfull() const;
	int queuecount() const;
	bool enqueue(const Item &item);
	bool dequeue(Item &item);
};

#endif // !QUEUE_H_

12.11 queue.cpp

//queue.cpp -- Queue and Customer methods
#include "queue.h"
#include <cstdlib>

Queue::Queue(int qs /* = Q_SIZE */) :qsize(qs)
{
	front = rear = NULL;
	items = 0;
}

Queue::~Queue()
{
	Node * temp;
	while (front != NULL)
	{
		temp = front;
		front = front->next;
		delete temp;
	}
}

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

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

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

bool Queue::enqueue(const Item &item)
{
	if (isfull())
		return false;
	Node * add = new Node;
	add->item = item;
	add->next = NULL;
	items++;
	if (front == NULL)
		front = add;
	else
		rear->next = add;
	rear = add;
	return true;
}

bool Queue::dequeue(Item &item)
{
	if (front == NULL)
		return false;
	item = front->item;
	items--;
	Node * temp = front;
	front = front->next;
	delete temp;
	if (items == 0)
		rear = NULL;
	return true;
}

void Customer::set(long when)
{
	processtime = std::rand() % 3 + 1;
	arrive = when;
}

12.12  bank.cpp

//bank.cpp -- using the Queue interface
//compile with queue.cpp
#include <iostream>
#include <cstdlib>
#include <ctime>
#include "queue.h"

const int MIN_PER_HR = 60;

bool newcustomer(double x);

int main()
{
	using namespace std;
	srand(time(0));

	cout << "Case Study: Bank of Heather Automatic Teller\n";
	cout << "Enter maximum size of queue: ";
	int qs;
	cin >> qs;
	Queue line(qs);

	cout << "Enter the number of simulation hours: ";
	int hours;
	cin >> hours;
	long cyclelimit = MIN_PER_HR * hours;

	cout << "Enter the average number of customers per hour: ";
	double perhour;
	cin >> perhour;
	double min_per_cust;
	min_per_cust = MIN_PER_HR / perhour;

	Item temp;
	long turnaways = 0;
	long customers = 0;
	long served = 0;
	long sum_line = 0;
	int wait_time = 0;
	long line_wait = 0;

	for (int cycle = 0; cycle < cyclelimit; cycle++)
	{
		if (newcustomer(min_per_cust))
		{
			if (line.isfull())
				turnaways++;
			else
			{
				customers++;
				temp.set(cycle);
				line.enqueue(temp);
			}
		}
		if (wait_time < = 0 && !line.isempty())
		{
			line.dequeue(temp);
			wait_time = temp.ptime();
			line_wait += cycle - temp.when();
			served++;
		}
		if (wait_time > 0)
			wait_time--;
		sum_line += line.queuecount();
	}

	if (customers > 0)
	{
		cout << "customers accepted: " << customers << endl;
		cout << " customers served: " << served << endl;
		cout << "    turnaways: " << turnaways << endl;
		cout << "average queue size: ";
		cout.precision(2);
		cout.setf(ios_base::fixed, ios_base::floatfield);
		cout << (double)sum_line / cyclelimit << endl;
		cout << "averahe wait time: " << (double)line_wait / served << " minutes\n";
	}
	else
		cout << "No customers!\n";
	cout << "Done!\n";
	return 0;
}


bool newcustomer(double x)
{
	return(rand()*x / RAND_MAX < 1);
}

相關推薦

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++PrimerPlus_第十二章 類和動態記憶體分配

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

C++Primer Plus筆記——第十一章 使用類及課後程式設計練習答案

目錄 本章小結 程式清單 本章小結       本章介紹了定義和使用類的許多重要方面，其中的一些內容可能比較難理解，但隨著實踐經驗的不斷增加，您將逐步掌握他們。        一般來說，訪問私有類成員的唯一方法是使用類方法。C++使用友元

C++Primer Plus筆記——第十四章 C++中的程式碼重用總結及程式清單

目錄 本章小結 程式清單 本章小結         C++提供了幾種重用程式碼的手段。第13章介紹的公有繼承能夠建立is-a關係，這樣派生類可以重用基類的程式碼。私有繼承和保護繼承也使得能夠重用基類的程式碼。但建立的

C++Primer Plus筆記——第十四章 C++中的程式碼重用課後程式設計練習答案

程式設計練習答案 習題1     習題2     習題3    習題4    習題5 習題1 //winec.h #ifndef WINEC_H_ #define WINEC_H_ #include <iostream> #include <strin

C++Primer Plus筆記——第十七章 輸入、輸出和檔案總結及程式清單

目錄 本章小結 程式清單 核心格式化 本章小結        流是進出程式的位元組流。緩衝區足記憶體中的臨時儲存區域，是程式與檔案或其他I/O裝置之間的橋樑。 資訊在緩衝區和檔案之間傳輸時，將使用裝置（如磁碟驅動器）處理效率最高的尺寸

C++Primer Plus筆記——第十五章 友元、異常和其他總結及程式清單

目錄 本章小結 程式清單 友元類 巢狀類  異常 本章小結        友元使得能夠為類開發更靈活的介面。類可以將其他函式、其他類和其他類的成員函式作為友元。在某些情況下，可能需要使用前向宣告，需要特別注意類和方法宣告的順序

C++Primer Plus筆記——第十六章 string類和標準模板庫總結及程式清單

目錄 本章小結 程式清單 標準模板庫 泛型程式設計 函式物件 演算法 其他庫 本章小結        C++提供了一組功能強大的庫，這些庫提供了很多常見程式設計問題的解決方案以及簡化其他問題的工具。 string類為將字串

C++Primer Plus筆記——第十五章 友元、異常和其他課後程式設計練習答案

課後程式設計練習答案 習題1                習題2               習題3             習題4 習題1 //tv.h #ifndef TV_H_ #define TV_H_ #include <iostream> u

C++Primer Plus筆記——第十七章 輸入、輸出和檔案課後程式設計練習答案

課後程式設計練習答案 習題1              習題2             習題3            習題4              習題5            習題6 習題1 #include<iostream> int main(

第十二章 類和動態內存分配

其它 成對 關鍵字 類型 fault ptr 釋放緩存 別名 返回 靜態成員變量 不能在類聲明中初始化靜態成員變量（聲明描述了如何分配內存，但並不分配內存）； 可以在類聲明之外（在方法文件中）用單獨的語句初始化靜態成員變量； 初始化語句必須指出類型，並使用作用域解析運算符，

C++ Primer Plus 筆記第十章

cpp 類方法 12px 程序員 數據隱藏 第十章 10.8 ans 函數定義 對象和類 OOP特性： 　　 1. 抽象 　　 2. 封裝和數據隱藏 　　 3. 多態 　　 4. 繼承 　　 5. 代碼的可重用性 10.1 過程性編程和面向對象編程 　　 采用OOP方法時：

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

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

c++ primer 筆記第十二章動態記憶體

第十二章：動態記憶體 梗概：本章主要講解使用C++智慧指標動態管理記憶體以及直接管理動態記憶體的方法以及他們的結合。 靜態記憶體儲存static變數以及定義在所有函式之外的變數。棧記憶體儲存函式之內的非static變數，堆記憶體用來分配給程式動態產生的物件。靜態記憶體和棧記憶體中的變數由編譯

C++ Primer Plus 筆記第五章

read 入口 繼續 返回 計算表達 文件 沒有初始化 fin all for循環的組成部分： 　　 1. 設置初始值。 　　 2. 執行測試，看看循環是否應當繼續進行。 　　 3. 執行循環操作。 　　 4. 更新用於測試的值。 表達式和語句： 　　 表達式：任何值和

C++ Primer Plus 筆記第七章

處的 進入 code pri name 結束 show 素數 設置 復習函數基本知識： 　　要使用C++函數，要完成工作： 　　　　 1. 提供函數基本知識； 　　 　　2. 提供函數原型； 　　 　　3. 調用函數 　　 庫函數是已經定義和編譯好的函數，同時可以使用標

C++ Primer Plus 筆記第八章

機制 設計 改變 etl cin 它的 數組 程序 類對象 C++內聯函數： 　　 內聯函數的編譯代碼與其他程序代碼 “內聯” 起來了，編譯器將使用相應的函數代碼替換函數調用； 　　 對於內聯函數，程序無需跳到另一個位置處執行代碼，再跳回來： 　　　　內聯函數的運行速

C++ Primer Plus 筆記第九章

存儲 開發 除了 ostream ger rime 前途 內部鏈接 模型 內存模型與名稱空間 9.1 單獨編譯 　　 C++ 允許鼓勵將組件函數放在獨立的文件中，可以單獨編譯這些文件，然後將他們鏈接成可執行程序； 　　 例程： 　　 頭文件： coordin.h 　

CLR via C#學習筆記-第十二章-泛型

vat message 靜態 定義 泛型接口 void 失敗 internal 運行時 泛型是CLR和編程語言提供的一種特殊機制，他支持另一種形式的代碼重用，即算法重用。 CLR允許創建泛型引用類型和泛型值類型，但不允許創建泛型枚舉類型。 此外CLR還允許創建泛型接口和泛型