2. 程式人生 > >5.4-day04-C++拷貝建構函式/靜態成員

5.4-day04-C++拷貝建構函式/靜態成員

阿新 • • 發佈：2018-11-29
一、拷貝建構函式和拷貝賦值運算子 1.拷貝構造：用一個已有的物件，構造和它同類型的副本物件——克隆。 2.形如 class X {   X (const X& that) { ... } }; 的建構函式成為拷貝建構函式。如果一個類沒有定義拷貝建構函式，系統會提供一個預設拷貝建構函式。預設拷貝建構函式對於基本型別的成員變數，按位元組複製，對於類型別的成員變數，呼叫相應型別的拷貝建構函式。 3.在某些情況就下，預設拷貝建構函式只能實現淺拷貝，如果需要獲得深拷貝的複製效果，就需要自己定義拷貝建構函式。 4.形如 class X {   X& operator= (const X& that) {     ...   } }; 的成員函式稱為拷貝賦值運算子函式。如果一個類沒有定義拷貝賦值運算子函式，系統會提供一個預設拷貝賦值運算子函式。預設拷貝賦值運算子函式對於基本型別的成員變數，按位元組複製，對於類型別的成員變數，呼叫相應型別的拷貝賦值運算子函式。 5.在某些情況就下，預設拷貝賦值運算子函式只能實現淺拷貝，如果需要獲得深拷貝的複製效果，就需要自己定義拷貝賦值運算子函式。 練習：實現一個簡化版的字串類String支援： 1.用字元指標形式的字串構造 2.拷貝構造和拷貝賦值 3.獲取字元指標形式字串的成員函式，類似string::c_str 說明：不得使用std::string！ 二、靜態成員 1.靜態成員變數和靜態成員函式是屬於類的而非屬於物件。 2.靜態成員變數，為多個物件所共享，只有一份例項，可以通過物件訪問也可以通過類訪問，必須在類的外部定義並初始化。靜態成員變數本質上與全域性變數並沒有區別，只是多了類作用域的約束，和訪控屬性的限制。 class Account { private:   string m_name;   double m_balance;   static double m_rate; }; 3.靜態成員函式，沒有this指標，無法訪問非靜態成員。 4.單例模式 三、成員指標 Student s; string* p = &s.m_name; // 不是 Student s2; (一)成員變數指標 1.定義 成員變數型別 類名::*指標變數名; string Student::*pname; int Student::*page; 2.初始化/賦值 指標變數名 = &類名::成員變數名 pname = &Student::m_name; page = &Student::m_age; 3.解引用 物件.*指標變數名 物件指標->*指標變數名 Student s, *p = &s; s.*pname = "張飛"; cout << p->*page << endl; (二)成員函式指標 1.定義 成員函式返回型別 (類名::*指標變數名) (引數表) void (Student::*plearn) (const string&) const; 2.初始化/賦值 指標變數名 = &類名::成員函式名; plearn = &Stduent::learn; 3.解引用 (物件.*指標變數名) (實參表); (物件指標->*指標變數名) (實參表); (s.*plearn) ("C++"); (p->*plearn) ("UNIX"); 第三課  操作符過載 複數：3+4i Complex c1 - (c2 + c3) c1.sub (c2.add (c3))  一、操作符標記和操作符函式 1.雙目操作符：L#R 成員函式形式：L.operator# (R) 左調右參 全域性函式形式：::operator# (L, R) 左一右二 2.單目操作符：#O/O# 成員函式形式：O.operator# () 全域性函式形式：::operator# (O) 3.三目操作符：不考慮 二、雙目操作符 1.+/-/*// 運算元在計算前後不變。 表示式的值是右值。
complex.cpp 
   
    
    
  1. #include <iostream>
    2. 
    
  2. using namespace std;
    3. 
    
  3. class Complex {
    4. 
    
  4. public:
    5. 
    
  5. 	Complex (int r = 0, int i = 0) :
    6. 
    
  6. 		m_r (r), m_i (i) {}
    7. 
    
  7. 	void print (void) const {
    8. 
    
  8. 		cout << m_r << '+' << m_i << 'i' << endl;
    9. 
    
  9. 	}
    10. 
    
  10. 	// 第一個const：返回右值
     
    11. 
    
  11. 	// 第二個const：支援常量型右運算元
    12. 
    
  12. 	// 第三個const：支援常量型左運算元
    13. 
    
  13. 	const Complex operator+ (
    14. 
    
  14. 		const Complex& r) const {
    15. 
    
  15. 		return Complex (m_r + r.m_r, m_i + r.m_i);
    16. 
    
  16. 	}
    17. 
    
  17. private:0
    18. 
    
  18. 	int m_r;
    19. 
    
  19. 	int m_i;
    20. 
    
  20. 	friend const Complex operator- (const Complex&,
    21. 
    
  21. 		const Complex&);
    22. 
    
  22. };
     
    23. 
    
  23. const Complex operator- (const Complex& l,
    24. 
    
  24. 	const Complex& r) {
    25. 
    
  25. 	return Complex (l.m_r - r.m_r, l.m_i - r.m_i);
    26. 
    
  26. }
    27. 
    
  27. int main (void) {
    28. 
    
  28. 	const Complex c1 (1, 2);
    29. 
    
  29. 	c1.print ();
    30. 
    
  30. 	const Complex c2 (3, 4);
    31. 
    
  31. 	Complex c3 = c1 + c2; // c3 = c1.operator+ (c2)
    32. 
    
  32. 	c3.print 
     
    (); // 4+6i
    33. 
    
  33. //	(c1 + c2) = c3;
    34. 
    
  34. 	c3 = c2 - c1; // c3 = ::operator- (c2, c1)
    35. 
    
  35. 	c3.print (); // 2+2i
    36. 
    
  36. 	return 0;
    37. 
    
  37. }
    38.

hungry.cpp 
   
    
    
  1. #include <iostream>
    2. 
    
  2. using namespace std;
    3. 
    
  3. // 餓漢方式
    4. 
    
  4. class Singleton {
    5. 
    
  5. public:
    6. 
    
  6. 	static Singleton& getInst (void) {
    7. 
    
  7. 		return s_inst;
    8. 
    
  8. 	}
    9. 
    
  9. private:
    10. 
    
  10. 	Singleton (void) {}
    11. 
    
  11. 	Singleton (const Singleton&);
    12. 
    
  12. 	static Singleton s_inst;
    13. 
    
  13. };
    14. 
    
  14. Singleton Singleton::s_inst;
    15. 
    
  15. int main (void) {
    16. 
    
  16. 	Singleton& s1 = Singleton::getInst ();
    17. 
    
  17. 	Singleton& s2 = Singleton::getInst ();
    18. 
    
  18. 	Singleton& s3 = Singleton::getInst ();
    19. 
    
  19. 	cout << &s1 << ' ' << &s2 << ' ' << &s3 << endl;
    20. 
    
  20. 	return 0;
    21. 
    
  21. }
    22.
 
integer.cpp 
   
    
    
  1. #include <iostream>
    2. 
    
  2. using namespace std;
    3. 
    
  3. class Integer {
    4. 
    
  4. public:
    5. 
    
  5. 	Integer (int data = 0) : m_data (data) {}
    6. 
    
  6. 	void print (void) const {
    7. 
    
  7. 		cout << m_data << endl;
    8. 
    
  8. 	}
    9. 
    
  9. 	/*
    10. 
    
  10. 	Integer (const Integer& that) :
    11. 
    
  11. 		m_data (that.m_data) {
    12. 
    
  12. 		cout << "拷貝構造" << endl;
    13. 
    
  13. 	}
    14. 
    
  14. 	*/
    15. 
    
  15. private:
    16. 
    
  16. 	int m_data;
    17. 
    
  17. };
    18. 
    
  18. void foo (Integer i) {
    19. 
    
  19. 	i.print ();
    20. 
    
  20. }
    21. 
    
  21. Integer bar (void) {
    22. 
    
  22. 	Integer i;
    23. 
    
  23. 	return i;
    24. 
    
  24. }
    25. 
    
  25. int main (void) {
    26. 
    
  26. 	Integer i1 (10);
    27. 
    
  27. 	i1.print ();
    28. 
    
  28. 	Integer i2 (i1); // 拷貝構造
    29. 
    
  29. 	i2.print ();
    30. 
    
  30. 	Integer i3 = i1; // 拷貝構造
    31. 
    
  31. 	i3.print ();
    32. 
    
  32. //	Integer i4 (10, 20);
    33. 
    
  33. 	cout << "呼叫foo()函式" << endl;
    34. 
    
  34. 	foo (i1);
    35. 
    
  35. 	cout << "呼叫bar()函式" << endl;
    36. 
    
  36. 	Integer i4 (bar ());
    37. 
    
  37. 	return 0;
    38. 
    
  38. }
    39.
 
integer2.cpp 
   
    
    
  1. #include <iostream>
    2. 
    
  2. using namespace std;
    3. 
    
  3. class Integer {
    4. 
    
  4. public:
    5. 
    
  5. 	Integer (int data) : m_data (new int (data)) {}
    6. 
    
  6. 	~Integer (void) {
    7. 
    
  7. 		if (m_data) {
    8. 
    
  8. 			delete m_data;
    9. 
    
  9. 			m_data = NULL;
    10. 
    
  10. 		}
    11. 
    
  11. 	}
    12. 
    
  12. 	void print (void) const {
    13. 
    
  13. 		cout << *m_data << endl;
    14. 
    
  14. 	}
    15. 
    

    16. 
    
  16. 	Integer (const Integer& that) :
    17. 
    
  17. 		m_data (new int (*that.m_data)) {}
    18. 
    
  18. 	void set (int data) {
    19. 
    
  19. 		*m_data = data;
    20. 
    
  20. 	}
    21. 
    
  21. 	Integer& operator= (const Integer& that) {
    22. 
    
  22. 		// 防止自賦值
    23. 
    
  23. 		if (&that != this) {
    24. 
    
  24. 			// 釋放舊資源
    25. 
    
  25. 			delete m_data;
    26. 
    
  26. 			// 分配新資源
    27. 
    
  27. 			m_data = new int (*that.m_data);
    28. 
    
  28. 			// 拷貝新資料
    29. 
    
  29. 		}
    30. 
    
  30. 		// 返回自引用
    31. 
    
  31. 		return *this;
    32. 
    
  32. 	}
    33. 
    
  33. private:
    34. 
    
  34. 	int* m_data;
    35. 
    
  35. };
    36. 
    
  36. int main (void) {
    37. 
    
  37. 	Integer i1 (10);
    38. 
    
  38. 	i1.print ();
    39. 
    
  39. 	Integer i2 (i1);
    40. 
    
  40. 	i2.print ();
    41. 
    
  41. 	i2.set (20);
    42. 
    
  42. 	i2.print ();
    43. 
    
  43. 	i1.print ();
    44. 
    
  44. 	Integer i3 (30);
    45. 
    
  45. 	i3.print (); // 30
    46. 
    
  46. 	i3 = i1; // 拷貝賦值
    47. 
    
  47. 	// i3.operator= (i1);
    48. 
    
  48. 	i3.print (); // 10
    49. 
    
  49. 	i3.set (40);
    50. 
    
  50. 	i3.print (); // 40
    51. 
    
  51. 	i1.print (); // 10
    52. 
    
  52. 	/*
    53. 
    
  53. 	int a = 10, b = 20, c = 30;
    54. 
    
  54. 	(a = b) = c;
    55. 
    
  55. 	cout << a << endl;
    56. 
    
  56. 	*/
    57. 
    
  57. 	(i3 = i1) = i2;
    58. 
    
  58. //	i3.operator=(i1).operator=(i2);
    59. 
    
  59. 	i3.print ();
    60. 
    
  60. 	i3 = i3;
    61. 
    
  61. 	i3.print ();
    62. 
    
  62. 	return 0;
    63. 
    
  63. }
    64.
 
lazy.cpp 
   
    
    
  1. #include <iostream>
    2. 
    
  2. using namespace std;
    3. 
    
  3. // 懶漢方式
    4. 
    
  4. class Singleton {
    5. 
    
  5. public:
    6. 
    
  6. 	static Singleton& getInst (void) {
    7. 
    
  7. 		if (! m_inst)
    8. 
    
  8. 			m_inst = new Singleton;
    9. 
    
  9. 		++m_cn;
    10. 
    
  10. 		return *m_inst;
    11. 
    
  11. 	}
    12. 
    
  12. 	void releaseInst (void) {
    13. 
    
  13. 		if (m_cn && --m_cn == 0)
    14. 
    
  14. 			delete this;
    15. 
    
  15. 	}
    16. 
    
  16. private:
    17. 
    
  17. 	Singleton (void) {
    18. 
    
  18. 		cout << "構造：" << this << endl;
    19. 
    
  19. 	}
    20. 
    
  20. 	Singleton (const Singleton&);
    21. 
    
  21. 	~Singleton (void) {
    22. 
    
  22. 		cout << "析構：" << this << endl;
    23. 
    
  23. 		m_inst = NULL;
    24. 
    
  24. 	}
    25. 
    
  25. 	static Singleton* m_inst;
    26. 
    
  26. 	static unsigned int m_cn;
    27. 
    
  27. };
    28. 
    
  28. Singleton* Singleton::m_inst = NULL;
    29. 
    
  29. unsigned int Singleton::m_cn = 0;
    30. 
    
  30. int main (void) {
    31. 
    
  31. 	Singleton& s1 = Singleton::getInst ();
    32. 
    
  32. 	Singleton& s2 = Singleton::getInst ();
    33. 
    
  33. 	Singleton& s3 = Singleton::getInst ();
    34. 
    
  34. 	cout << &s1 << ' ' << &s2 << ' ' << &s3 << endl;
    35. 
    
  35. 	s3.releaseInst ();
    36. 
    
  36. 	s2.releaseInst ();
    37. 
    
  37. 	s1.releaseInst ();
    38. 
    
  38. 	return 0;
    39. 
    
  39. }
    40.
memptr.cpp 
   
    
    
  1. #include <iostream>
    2. 
    
  2. #include <cstring>
    3. 
    
  3. using namespace std;
    4. 
    
  4. class Student {
    5. 
    
  5. public:
    6. 
    
  6. 	Student (const string& name, int age) :
    7. 
    
  7. 		m_name (name), m_age (age) {}
    8. 
    
  8. 	double m_weight;
    9. 
    
  9. 	string m_name;
    10. 
    
  10. 	int m_age;
    11. 
    
  11. 	void learn (const string& lesson) const {
    12. 
    
  12. 		cout << "我在學" << lesson << endl;
    13. 
    
  13. 	}
    14. 
    
  14. 	static void hello (void) {
    15. 
    
  15. 		cout << "你好！" << endl;
    16. 
    
  16. 	}
    17. 
    
  17. };
    18. 
    
  18. int main (void) {
    19. 
    
  19. 	string Student::*pname = &Student::m_name;
    20. 
    
  20. 	void* pv;
    21. 
    
  21. 	memcpy (&pv, &pname, 4);
    22. 
    
  22. 	cout << pv << endl;
    23. 
    
  23. 	int Student::*page = &Student::m_age;
    24. 
    
  24. 	memcpy (&pv, &page, 4);
    25. 
    
  25. 	cout << pv << endl;
    26. 
    
  26. 	Student s ("張飛", 25), *p = &s;
    27. 
    
  27. 	cout << s.*pname << endl;
    28. 
    
  28. 	cout << p->*page << endl;
    29. 
    
  29. 	Student s2 ("趙雲", 22);
    30. 
    
  30. 	cout << s2.*pname << endl;
    31. 
    
  31. 	void (Student::*plearn) (const string&) const =
    32. 
    
  32. 		&Student::learn;
    33. 
    
  33. 	(s.*plearn) ("C++");
    34. 
    
  34. 	(p->*plearn) ("UNIX");
    35. 
    
  35. 	void (*phello) (void) = Student::hello;
    36. 
    
  36. 	phello ();
    37. 
    
  37. 	return 0;
    38. 
    
  38. }
    39.
 
private.cpp 
   
    
    
  1. #include <iostream>
    2. 
    
  2. using namespace std;
    3. 
    
  3. class Nocopy {
    4. 
    
  4. public:
    5. 
    
  5. 	Nocopy (void) {}
    6. 
    
  6. private:
    7. 
    
  7. 	Nocopy (const Nocopy&);
    8. 
    
  8. 	Nocopy& operator= (const Nocopy&);
    9. 
    
  9. };
    10. 
    
  10. void foo (ostream os) {
    11. 
    
  11. 	os << "Hello, World !" << endl;
    12. 
    
  12. }
    13. 
    
  13. int main (void) {
    14. 
    
  14. 	Nocopy n1;
    15. 
    
  15. 	Nocopy n2 = n1;
    16. 
    
  16. 	Nocopy n3;
    17. 
    
  17. 	n3 = n1;
    18. 
    
  18. 	foo (cout);
    19. 
    
  19. 	return 0;
    20. 
    
  20. }
    21.
 

static.cpp 
   
    
    
  1. #include <iostream>
    2. 
    
  2. using namespace std;
    3. 
    
  3. class A {
    4. 
    
  4. public:
    5. 
    
  5. 	static int m_i;
    6. 
    
  6. 	static void foo (void) {
    7. 
    
  7. 		cout << "foo：" << m_i << endl;
    8. 
    
  8. //		m_d = 3.14;
    9. 
    
  9. //		bar ();
    10. 
    
  10. 	}cd 
    11. 
    
  11. 	double m_d;
    12. 
    
  12. 	void bar (void) {
    13. 
    
  13. 		m_i = 1000;
    14. 
    
  14. 		foo ();
    15. 
    
  15. 	}
    16. 
    
  16. };
    17. 
    
  17. int A::m_i = 1;
    18. 
    
  18. int main (void) {
    19. 
    
  19. 	A::m_i = 10;
    20. 
    
  20. 	A a1, a2;
    21. 
    
  21. 	cout << ++a1.m_i << endl;
    22. 
    
  22. 	cout << a2.m_i << endl;
    23. 
    
  23. 	A::foo ();
    24. 
    
  24. 	a1.foo ();
    25. 
    
  25. 	a1.bar ();
    26. 
    
  26. 	return 0;
    27. 
    
  27. }
    28.
 
string.cpp 
   
    
    
  1. #include <iostream>
    2. 
    
  2. #include <cstring>
    3. 
    
  3. ::using namespace std;
    4. 
    
  4. class String {
    5. 
    
  5. public:
    6. 
    
  6. 	String (const char* str = NULL) {
    7. 
    
  7. 		m_str = new char[strlen(str?str:"")+1];
    8. 
    
  8. 		strcpy (m_str, str ? str : "");
    9. 
    
  9. 	}
    10. 
    
  10. 	~String (void) {
    11. 
    
  11. 		if (m_str) {
    12. 
    
  12. 			delete[] m_str;
    13. 
    
  13. 			m_str = NULL;
    14. 
    
  14. 		}
    15. 
    
  15. 	}
    16. 
    
  16. 	String (const String& that) :
    17. 
    
  17. 		m_str (strcpy (
    18. 
    
  18. 			new char[strlen(that.m_str)+1],
    19. 
    
  19. 			that.m_str)) {}
    20. 
    
  20. 	/* 菜鳥
    21. 
    
  21. 	void operator= (const String& that) {
    22. 
    
  22. 		m_str = new char[strlen(that.m_str)+1];
    23. 
    
  23. 		strcpy (m_str, that.m_str);
    24. 
    
  24. 	}*/
    25. 
    
  25. 	String& operator= (const String& that) {
    26. 
    
  26. 		if (&that != this) {
    27. 
    
  27. 			/* 小鳥
    28. 
    
  28. 			delete[] m_str;
    29. 
    
  29. 			m_str = new char[strlen(that.m_str)+1];
    30. 
    
  30. 			strcpy (m_str, that.m_str);
    31. 
    
  31. 			*/
    32. 
    
  32. 			/* 大鳥
    33. 
    
  33. 			char* str = 
    34. 
    
  34. 				new char[strlen(that.m_str)+1];
    35. 
    
  35. 			delete[] m_str;
    36. 
    
  36. 			m_str = strcpy (str, that.m_str);
    37. 
    
  37. 			*/
    38. 
    
  38. 			// 老鳥
    39. 
    
  39. 			String temp (that);
    40. 
    
  40. 			swap (m_str, temp.m_str);
    41. 
    
  41. 		}
    42. 
    
  42. 		return *this;
    43. 
    
  43. 	}
    44. 
    
  44. 	const char* c_str (void) const {
    45. 
    
  45. 		return m_str;
    46. 
    
  46. 	}
    47. 
    
  47. private:
    48. 
    
  48. 	char* m_str;
    49. 
    
  49. };
    50. 
    
  50. int main (void) {
    51. 
    
  51. 	String s1 ("Hello, World !");
    52. 
    
  52. 	cout << s1.c_str () << endl;
    53. 
    
  53. 	String s2 = s1;
    54. 
    
  54. 	cout << s2.c_str () << endl;
    55. 
    
  55. 	String s3 ("Hello, Linux !");
    56. 
    
  56. 	try {
    57. 
    
  57. 		s1 = s3;
    58. 
    
  58. 	}
    59. 
    
  59. 	catch (exception& ex) {
    60. 
    
  60. 		cout << ex.what () << endl;
    61. 
    
  61. 	}
    62. 
    
  62. 	cout << s1.c_str () << endl;
    63. 
    
  63. 	return 0;
    64. 
    
  64. }
    65.
   拷貝構造：        如果一個類沒有定義拷貝建構函式，系統會提供一個預設拷貝建構函式。預設拷貝建構函式對於基本型別的成員變數，按位元組複製，對於類型別的成員變數，呼叫相應型別的拷貝建構函式。



來自為知筆記(Wiz)

相關推薦

5.4-day04-C++拷貝建構函式/靜態成員

一、拷貝建構函式和拷貝賦值運算子 1.拷貝構造：用一個已有的物件，構造和它同類型的副本物件——克隆。 2.形如 class X {   X (const X& that) { ... } }; 的建構函式成為拷

C++ 拷貝建構函式程式碼筆記

拷貝建構函式是一種特殊的建構函式，它在建立物件時，是使用同一類中之前建立的物件來初始化新建立的物件。拷貝建構函式通常用於： 通過使用另一個同類型的物件來初始化新建立的物件。 複製物件把它作為引數傳遞給函式。 複製物件，並從函式返回這個物件 #include

C++ 拷貝建構函式this指標練習

總時間限制:  1000ms   記憶體限制:  65536kB // 在此處補充你的程式碼 描述 程式填空，使其按要求輸出 #include <iostream> using namespace std; class A {

C++ 拷貝建構函式練習

總時間限制:  1000ms   記憶體限制:  65536kB // 在此處補充你的程式碼 描述 程式填空，使其輸出9 22 5 #include <iostream> using namespace std; class

C++拷貝建構函式 的理解

#include <iostream> using namespace std; //拷貝建構函式的理解 class Point { public: Point(); Point(int X, int Y); ~Point(); Point(Point

C++ 拷貝建構函式和賦值運算子

本文主要介紹了拷貝建構函式和賦值運算子的區別，以及在什麼時候呼叫拷貝建構函式、什麼情況下呼叫賦值運算子。最後，簡單的分析了下深拷貝和淺拷貝的問題。 拷貝建構函式和賦值運算子 在預設情況下（使用者沒有定義，但是也沒有顯式的刪除），編譯器會自動的隱式生成一個拷貝建構函式和賦值

C++拷貝建構函式和運算子過載（VC實現）

String.h檔案： #ifndef STRING_H #define STRING_H #include <ostream> using namespace std; class String { public: String(){ m_pStr = nullptr

C++ 拷貝建構函式中淺拷貝與深拷貝

淺拷貝建構函式 看一段拷貝建構函式的程式碼 #include <iostream> #include <cstring> using namespace std; class Array{ public : Array()

C++ 拷貝建構函式和過載賦值操作符不能相互呼叫

拷貝建構函式呼叫過載賦值操作符，過載賦值操作符呼叫拷貝建構函式的寫法都是沒有意義的。首先：拷貝建構函式的存在意義--------是通過已有的物件構造新的物件，構造完畢後才有兩個物件；過載賦值操作符的意義-----------將一個物件的值賦給另一個物件，兩個物件都已經構造完畢了。拷貝建構函式----呼叫---

C++:拷貝建構函式&賦值運算子的過載函式

拷貝建構函式：          用一個已經存在的物件來生成一個相同型別的新物件。（淺拷貝）預設的拷貝建構函式：          如果自定義了拷貝建構函式，編譯器就不在生成預設的拷貝建構函

C ++ 拷貝建構函式和賦值建構函式 非常經典

C++ 拷貝建構函式 賦值建構函式 拷貝建構函式和賦值建構函式的異同 由於並非所有的物件都會使用拷貝建構函式和賦值函式，程式設計師可能對這兩個函式有些輕視。請先記住以下的警告，在閱讀正文時就會多心：如果不主動編寫拷貝建構函式和賦值函式，編譯器將以“位拷貝”的方式自動生成預設的函式。倘若類中含有指標變數，那麼

在C++拷貝建構函式中使用初始化列表

    今天同事遇到一個關於拷貝建構函式的問題。程式碼大致如下： class test { public: test( size_t size ) { v.assign( size, 1 ); } test( const test& rhs)

C++拷貝建構函式的引數必須為引用

引數為引用，不為值傳遞是為了防止拷貝建構函式的無限遞迴，最終導致棧溢位。如果複製建構函式是這樣的 ： test(test t);我們呼叫test ort;test a(ort）;--> test.

C++拷貝建構函式_形參為什麼只能是引用（不能傳值或指標）

先給出答案： 拷貝建構函式不能用數值或指標形參原因，不是為了節省建立副本的空間與時間。而是那樣做會無限迴圈遞迴下去。 舉個例子來看一下為什麼會這樣。（反例） class Example() { public: Example(int a):aa(a) {}

c++拷貝建構函式遇上等號過載

參加完美世界的筆試題目，有個題目是拷貝建構函式呼叫，同時定義了“=”過載，這個時候 =過載函式是否會被呼叫？ 做了個實驗，呼叫拷貝建構函式進行初始化的時候，是不會呼叫=過載的。 #include<iostream> #include<vector>

c++拷貝建構函式和賦值操作符過載

c++拷貝建構函式： class A { A(const A& a); .... } 由於拷貝建構函式中，一般不允許對原物件進行修改，因此一般在引數中使用const關鍵字進行限制。 拷貝建構函式一般用於需要new記憶體等操作。如果不允許使用拷貝建

C++ 拷貝建構函式與賦值函式的區別（很嚴謹和全面）

這裡我們用類String 來介紹這兩個函式： 拷貝建構函式是一種特殊建構函式，具有單個形參，該形參（常用const修飾）是對該類型別的引用。當定義一個新物件並用一個同類型的物件對它進行初始化時，將顯式使用拷貝建構函式。為啥形參必須是對該型別的引用呢？試

c++拷貝建構函式 && 賦值語句

拷貝建構函式 拷貝建構函式的定義： 同一個類的物件在記憶體中有完全相同的結構，如果作為一個整體進行復制或拷貝是完全可行的（以為他們具有同樣的結構）。這個拷貝的過程只需要拷貝資料成員，而

C++拷貝建構函式和operator=

1 拷貝建構函式引數的特點對於一個類X,如果一個建構函式的第一個引數是下列之一:a) X&b) const X&c) volatile X&d) const volatile X&因此 X::X(X&, int=1); //是拷貝建構函

C++拷貝建構函式(深拷貝，淺拷貝)

對於普通型別的物件來說，它們之間的複製是很簡單的，例如：int a=88;int b=a; 而類物件與普通物件不同，類物件內部結構一般較為複雜，存在各種成員變數。下面看一個類物件拷貝的簡單例子。 #in