2. 程式人生 > >5.3-day03-C++建構函式/this指標/解構函式

5.3-day03-C++建構函式/this指標/解構函式

阿新 • • 發佈：2018-11-29
四、 5.建構函式 class 類名 {   ...   類名 (形參表) {     建構函式體;   } }; 當一個物件被建立時，建構函式會自動被執行，其引數來自構造實參。 int i = 10; int i (10); 6.建構函式可以通過構造引數實現過載 7.如果一個類沒有定義任何建構函式，那麼系統就會預設地為其提供一個無參建構函式，該建構函式對於基本型別的成員變數不做初始化，對於類型別的成員變數，呼叫其相應型別的無參建構函式初始化。 8.物件的建立過程 分配記憶體->呼叫建構函式           ->呼叫類型別成員的建構函式->建構函式的程式碼 9.初始化表 class 類名 {   類名(...) : 初始化表 {     建構函式體;   } }; const int x = 100; x = 100; int& a = b; a = b; 1)如果類中含有常量或引用型的成員變數，必須通過初始化表對其初始化。 2)成員變數的初始化順序僅於其被宣告的順序有關，而與初始化表的順序無關。 class A { public:    A (char* psz) : m_str (psz),       m_len (strlen (psz)) private:   size_t m_len;   string m_str; }; 練習：實現一個Clock類支援兩種工作模式，計時器和電子鐘。 00:01:00 14:05:37 #include <iomanip> cout << setw (10) << setfill ('0') << 12; 0000000012 Clock   時、分、秒   走 - 顯示、滴答 五、this指標 1.一般而言，在類的建構函式或成員函式中，關鍵字this表示一個指標，對於建構函式而言，this指向正在被構造的物件，對於成員函式而言，this指向呼叫該函式的物件。 2.this指標的用途 1)在類的內部區分成員變數。 2)在成員函式中返回呼叫物件自身。 3)在成員函式內部通過引數向外界傳遞呼叫物件自身，以實現物件間互動。 老 -問題-> 學 師 <-答案- 生 class A {   B& m_b; }; class B {   A& m_a; }; sizeof (A) ? class C {   C m_c; }; 六、常函式與常物件 1.如果在一個類的成員函式的引數表後面加上const關鍵字，那麼這個成員函式就被稱為常函式，常函式的this指標是一個常指標。在常函式內部無法修改成員變數，除非該變數具有mutable屬性。而且在常函式內部也無法呼叫非常函式。 2.常物件：擁有const屬性的物件，物件引用或指標。 常物件只能呼叫常函式。 同型的常函式和非常函式可以構成過載關係。常物件呼叫常版本，非常物件呼叫非常版本。如果沒有非常版本，非常物件也可以呼叫常版本。 const XXX 函式名 (const YYY yyy) const {   ... } 七、解構函式 class 類名 {   ~類名 (void) {      解構函式體;   } }; 當一個物件被銷燬時自動執行解構函式。 區域性物件離開作用域時被銷燬，堆物件被delete時被銷燬。 如果一個類沒有定義任何解構函式，那麼系統會提供一個預設解構函式。預設解構函式對基本型別的成員變數什麼也不幹，對類型別的成員變數，呼叫相應型別的解構函式。 一般情況下，在解構函式中釋放各種動態分配的資源。 構造：基類->成員->子類 析構：子類->成員->基類
1.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. void foo (const int& a) {
    4. 
     
  4. 	cout << a << endl;
    5. 
     
  5. }
    6. 
     
  6. int main (void) {
    7. 
     
  7. 	char c = 'A';
    8. 
     
  8. 	foo (static_cast<int> (c));
    9. 
     
  9. 	return 0;
    10. 
     
  10. }
    11.
 靜態型別轉換：
 static_cast <目標型別>(源型別變數)
argthis.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. class Student;
    4. 
     
  4. class Teacher {
    5. 
     
  5. public:
    6. 
     
  6. 	void educate (Student* s);
    7. 
     
  7. 	void reply (const string& answer) {
    8. 
     
  8. 		m_answer 
     
    = answer;
    9. 
     
  9. 	}
    10. 
     
  10. private:
    11. 
     
  11. 	string m_answer;
    12. 
     
  12. };
    13. 
     
  13. class Student {
    14. 
     
  14. public:
    15. 
     
  15. 	void ask (const string& question, Teacher* t) {
    16. 
     
  16. 		cout << "問題：" << question << endl;
    17. 
     
  17. 		t->reply ("不知道。");
    18. 
     
  18. 	}
    19. 
     
  19. };
    20. 
     
  20. void Teacher::educate (Student* s) 
     
    {
    21. 
     
  21. 	s->ask ("什麼是this指標？", this);
    22. 
     
  22. 	cout << "答案：" << m_answer << endl;
    23. 
     
  23. }
    24. 
     
  24. int main (void) {
    25. 
     
  25. 	Teacher t;
    26. 
     
  26. 	Student s;
    27. 
     
  27. 	t.educate (&s);
    28. 
     
  28. 	return 0;
    29. 
     
  29. }
    30.
 
  1. void ask (const string& question, Teacher* t) {
  2. cout << "問題：" << question << endl;
  3. t->reply ("不知道。");

 void Teacher::educate (Student* s) { s->ask ("什麼是this指標？", this); cout << "答案：" << m_answer << endl;
clock.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. #include <iomanip>
    3. 
     
  3. using namespace std;
    4. 
     
  4. class Clock {
    5. 
     
  5. public:
    6. 
     
  6. 	Clock (bool timer = true) :
    7. 
     
  7. 		m_hour (0), m_min (0), m_sec (0) {
    8. 
     
  8. 		if (! timer) {
    9. 
     
  9. 			time_t t = time (NULL);
    10. 
     
  10. 			tm* local = localtime (&t);
    11. 
     
  11. 			m_hour = local->tm_hour;
    12. 
     
  12. 			m_min = local->tm_min;
    13. 
     
  13. 			m_sec = local->tm_sec;
    14. 
     
  14. 		}
    15. 
     
  15. 	}
    16. 
     
  16. 	void run (void) {
    17. 
     
  17. 		for (;;) {
    18. 
     
  18. 			show ();
    19. 
     
  19. 			tick ();
    20. 
     
  20. 		}
    21. 
     
  21. 	}
    22. 
     
  22. private:
    23. 
     
  23. 	void show (void) {
    24. 
     
  24. 		cout << '\r' << setfill ('0')
    25. 
     
  25. 			<< setw (2) << m_hour << ':'
    26. 
     
  26. 			<< setw (2) << m_min << ':'
    27. 
     
  27. 			<< setw (2) << m_sec << flush;
    28. 
     
  28. //		printf ("\r%02d:%02d:%02d", m_hour,
    29. 
     
  29. //			m_min, m_sec);
    30. 
     
  30. 	}
    31. 
     
  31. 	void tick (void) {
    32. 
     
  32. 		sleep (1);
    33. 
     
  33. 		if (++m_sec == 60) {
    34. 
     
  34. 			m_sec = 0;
    35. 
     
  35. 			if (++m_min == 60) {
    36. 
     
  36. 				m_min = 0;
    37. 
     
  37. 				if (++m_hour == 24)
    38. 
     
  38. 					m_hour = 0;
    39. 
     
  39. 			}
    40. 
     
  40. 		}
    41. 
     
  41. 	}
    42. 
     
  42. 	int m_hour;
    43. 
     
  43. 	int m_min;
    44. 
     
  44. 	int m
    45. 
     
  45. };
    46. 
     
  46. int main (void) {
    47. 
     
  47. 	Clock clock (false);
    48. 
     
  48. 	clock.run ();
    49. 
     
  49. 	return 0;
    50. 
     
  50. }
    51.
  1. << setw (2) << m_hour << ':'
  2. << setw (2) << m_min << ':'
  3. << setw (2) << m_sec << flush;
setw 設定預寬； m_hour 指定填充字元；  cout << ......<< endl;      ‘\n’  cout << ......<< flush;   "把緩衝區裡的東西衝刷到螢幕上"
 
constfunc.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. class A {
    4. 
     
  4. public:
    5. 
     
  5. //	void bar (void) {
    6. 
     
  6. //		cout << "非常bar" << endl;
    7. 
     
  7. //	}
    8. 
     
  8. 	void bar (void) const {
    9. 
     
  9. 		cout << "常bar" << endl;
    10. 
     
  10. 	}
    11. 
     
  11. //  void XXXbarYYY (A* this) {}
    12. 
     
  12. 	void foo (void) const {
    13. 
     
  13. //		m_i = 100;
    14. 
     
  14. 		const_cast<A*>(this)->m_i = 100;
    15. 
     
  15. 	}
    16. 
     
  16. 	void print (void) const {
    17. 
     
  17. 		cout << m_i << endl;
    18. 
     
  18. 	}
    19. 
     
  19. //	_ZNK1A3fooEv (const A* this) {
    20. 
     
  20. //		const_cast<A*>(this)->m_i = 100;
    21. 
     
  21. //	}
    22. 
     
  22. 	int m_i;
    23. 
     
  23. };
    24. 
     
  24. void func (void) /*const*/ {}
    25. 
     
  25. int main (void) {
    26. 
     
  26. 	A a;
    27. 
     
  27. 	a.foo ();
    28. 
     
  28. 	a.print ();
    29. 
     
  29. 	const A& r = a;
    30. 
     
  30. 	r.bar ();
    31. 
     
  31. //	XXXbarYYY (&r); // const A*
    32. 
     
  32. 	a.bar ();
    33. 
     
  33. //	XXXbarYYY (&a); // A*
    34. 
     
  34. 	return 0;
    35. 
     
  35. }
    36.
 
init.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. int g_data = 1000;
    4. 
     
  4. class A {
    5. 
     
  5. public:
    6. 
     
  6. 	A (void) : m_c (100), m_r (g_data) {
    7. 
     
  7. //		m_c = 100;
    8. 
     
  8. ///		m_r = g_data;
    9. 
     
  9. 	}
    10. 
     
  10. 	void print (void) {
    11. 
     
  11. 		cout <initc << ' ' << m_r << endl;
    12. 
     
  12. 	}
    13. 
     
  13. private:
    14. 
     
  14. 	const int m_c;
    15. 
     
  15. 	int& m_r;
    16. 
     
  16. };
    17. 
     
  17. int main (void) {
    18. 
     
  18. 	A a;
    19. 
     
  19. 	a.print ();
    20. 
     
  20. 	return 0;
    21. 
     
  21. }
    22.

 

integer.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. class Double {
    4. 
     
  4. public:
    5. 
     
  5. 	Double (double data) :
    6. 
     
  6. 		m_data (new double (data)) {
    7. 
     
  7. 		cout << "構造" << endl;
    8. 
     
  8. 	}
    9. 
     
  9. 	~Double (void) {
    10. 
     
  10. 		cout << "析構" << endl;
    11. 
     
  11. 		delete m_data;
    12. 
     
  12. 	}
    13. 
     
  13. 	void print (void) const {
    14. 
     
  14. 		cout << *m_data << endl;
    15. 
     
  15. 	}
    16. 
     
  16. private:
    17. 
     
  17. 	double* m_data;
    18. 
     
  18. 	string m_lable;
    19. 
     
  19. };
    20. 
     
  20. int main (void) {
    21. 
     
  21. //	{
    22. 
     
  22. 		Double d1 (3.14);
    23. 
     
  23. 		d1.print ();
    24. 
     
  24. //	}
    25. 
     
  25. 	Double* d2 = new Double (1.23);
    26. 
     
  26. 	delete d2;
    27. 
     
  27. 	cout << "再見！" << endl;
    28. 
     
  28. 	return 0;
    29. 
     
  29. }
    30.
 
main.cpp 
    
    
     
  1. #include "s.h"
    2. 
     
  2. // 使用Student類
    3. 
     
  3. int main (void) {
    4. 
     
  4. 	Student s ("張飛", 25);
    5. 
     
  5. 	s.eat ("包子");
    6. 
     
  6. 	return 0;
    7. 
     
  7. }
    8.

retthis.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. class Counter {
    4. 
     
  4. public:
    5. 
     
  5. 	Counter (void) : m_data (0) {}
    6. 
     
  6. 	Counter& inc (void) {
    7. 
     
  7. 		++m_data;
    8. 
     
  8. 		return *this;
    9. 
     
  9. 	}
    10. 
     
  10. 	void print (void) {
    11. 
     
  11. 		cout << m_data << endl;
    12. 
     
  12. 	}
    13. 
     
  13. private:
    14. 
     
  14. 	int m_data;
    15. 
     
  15. };
    16. 
     
  16. int main (void) {
    17. 
     
  17. 	Counter c;
    18. 
     
  18. //	c.inc ();
    19. 
     
  19. //	c.inc ();
    20. 
     
  20. //	c.inc ();
    21. 
     
  21. 	c.inc ().inc ().inc ();
    22. 
     
  22. 	c.print (); // 3
    23. 
     
  23. 	return 0;
    24. 
     
  24. }
    25.
s.h 
    
    
     
  1. #ifndef _S_H
    2. 
     
  2. #define _S_H
    3. 
     
  3. #include <string>
    4. 
     
  4. using namespace std;
    5. 
     
  5. // 宣告Student類
    6. 
     
  6. class Student {
    7. 
     
  7. public:
    8. 
     
  8. 	Student (const string& name = "", int age = 0);
    9. 
     
  9. 	void eat (const string& food);
    10. 
     
  10. private:
    11. 
     
  11. 	string m_name;
    12. 
     
  12. 	int m_age;
    13. 
     
  13. };
    14. 
     
  14. #endif // _S_H
    15.


s.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. #include "s.h"
    4. 
     
  4. // 實現Student類
    5. 
     
  5. Student::Student (const string& name /* = "" */,
    6. 
     
  6. 	int age /* = 0 */) : m_name (name),
    7. 
     
  7. 	m_age (age) {}
    8. 
     
  8. void Student::eat (const string& food) {
    9. 
     
  9. 	cout << m_name << "，" << m_age << "，" << food
    10. 
     
  10. 		<< endl;
    11. 
     
  11. }
    12.

student.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. class A {
    4. 
     
  4. public:
    5. 
     
  5. 	A (int a) {}g++ g
    6. 
     
  6. };
    7. 
     
  7. class Student {
    8. 
     
  8. private:
    9. 
     
  9. 	string m_name;
    10. 
     
  10. 	int m_age;
    11. 
     
  11. 	A m_a;
    12. 
     
  12. public:
    13. 
     
  13. 	void eat (const string& food) {
    14. 
     
  14. 		cout << m_age << "歲的" << m_name
    15. 
     
  15. 			<< "同學正在吃" << food << "。" << endl;
    16. 
     
  16. 	}
    17. 
     
  17. //	void _ZN7Student3eatERKSs (Student* this,
    18. 
     
  18. //		const string& food) int{
    19. 
     
  19. //		cout << this->m_age << "歲的"<<this->m_name
    20. 
     
  20. //			<< "同學正在吃" << food << "。" << endl;
    21. 
     
  21. //	}
    22. 
     
  22. 	void setName (const string& name) {
    23. 
     
  23. 		if (name == "2")
    24. 
     
  24. 			cout << "你才" << name << "！" << endl;
    25. 
     
  25. 		else
    26. 
     
  26. 			m_name = name;
    27. 
     
  27. 	}
    28. 
     
  28. 	void setAge (int age) {
    29. 
     
  29. 		if (age < 0)
    30. 
     
  30. 			cout << "無效的年齡！" << endl;
    31. 
     
  31. 		else
    32. 
     
  32. 			m_age = age;
    33. 
     
  33. 	}
    34. 
     
  34. 	// 建構函式
    35. 
     
  35. 	Student (const string& name, int age) :
    36. 
     
  36. 		m_a (100) {
    37. 
     
  37. 		m_name = name;
    38. 
     
  38. 		m_age = age;
    39. 
     
  39. 	}
    40. 
     
  40. 	// 無參構造
    41. 
     
  41. 	Student (void) : m_a (100) {
    42. 
     
  42. 		m_name = "沒名";
    43. 
     
  43. 		m_age = 0;
    44. 
     
  44. 	}
    45. 
     
  45. 	// 單參構造
    46. 
     
  46. 	Student (const string& name) : m_a (100),
    47. 
     
  47. 		m_name (name), 	m_age (0) {
    48. 
     
  48. 		m_name = "哈哈";
    49. 
     
  49. 	}
    50. 
     
  50. };
    51. 
     
  51. int main (void) {
    52. 
     
  52. 	Student s1 ("張飛", 25);
    53. 
     
  53. 	s1.eat ("包子");
    54. 
     
  54. //	_ZN7Student3eatERKSs (&s1, "包子");
    55. 
     
  55. 	Student s2 = Student ("趙雲", 22);
    56. 
     
  56.     s2.eat ("燒餅");
    57. 
     
  57. //	_ZN7Student3eatERKSs (&s2, "燒餅");	
    58. 
     
  58. 	Student s3;
    59. 
     
  59. 	s3.eat ("煎餅果子");
    60. 
     
  60. 	Student* s4	= new Student ("關羽", 30);
    61. 
     
  61. 	s4->eat ("烤鴨");
    62. 
     
  62. 	delete s4;
    63. 
     
  63. 	Student& s5 = *new Student ();
    64. 
     
  64. 	s5.eat ("麵條");
    65. 
     
  65. 	delete &s5;
    66. 
     
  66. 	Student sa1[3] = {s1, s2};
    67. 
     
  67. 	sa1[0].eat ("KFC");
    68. 
     
  68. 	sa1[1].eat ("KFC");
    69. 
     
  69. 	sa1[2].eat ("KFC");
    70. 
     
  70. 	Student* sa2 = new Student[3] {s1, s2}; // 2011
    71. 
     
  71. 	sa2[0].eat ("KFC");
    72. 
     
  72. 	sa2[1].eat ("KFC");
    73. 
     
  73. 	sa2[2].eat ("KFC");
    74. 
     
  74. 	delete[] sa2;
    75. 
     
  75. 	Student s6 ("劉備");
    76. 
     
  76. 	s6.eat ("米飯");
    77. 
     
  77. 	return 0;
    78. 
     
  78. }
    79.
 
this.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. class A {
    4. 
     
  4. public:
    5. 
     
  5. 	A (int data) : data (data) {
    6. 
     
  6. 		cout << "構造: " << this << endl;:set cursorline
    7. 
     

    8. 
     
  8. //		this->data = data;
    9. 
     
  9. 	}
    10. 
     
  10. 	void foo (void) {
    11. 
     
  11. 		cout << "foo: " << this << endl;
    12. 
     
  12. 		cout << this->data << endl;
    13. 
     
  13. 	}
    14. 
     
  14. 	int data;
    15. 
     
  15. };
    16. 
     
  16. int main (void) {
    17. 
     
  17. 	A a (1000);
    18. 
     
  18. 	cout << "main: " << &a << endl;
    19. 
     
  19. 	a.foo ();
    20. 
     
  20. 	A* pa = new A (1000);
    21. 
     
  21. 	cout << "main: " << pa << endl;
    22. 
     
  22. 	pa->foo ();
    23. 
     
  23. 	delete pa;
    24. 
     
  24. }
    25.
   
 this指標：   一般而言，在類的建構函式或成員函式中，關鍵字this表示一個指標，    對於建構函式而言，this 指向正在被構造的物件，對於成員函式而言，    this指向呼叫該函式的物件。













來自為知筆記(Wiz)

相關推薦

5.3-day03-C++建構函式/this指標/解構函式

四、 5.建構函式 class 類名 {   ...   類名 (形參表) {     建構函式體;   } }; 當一個物件被建立時，建構函式會自動被執

c++ 如何把this指標傳入成員函式 像全域性函式一樣呼叫成員函式

測試這個功能的初衷是測試boost裡面的bind boost::bind((&A::sum), &a, _1, _2) 上面的程式碼是我boost bind及多執行緒這篇部落格裡面的一行程式碼。我就想boost是怎麼做到這樣呼叫一個類的成員函式的。其實成員

1、【C++】類&物件/建構函式/拷貝建構函式/操作符過載/解構函式

一、C++類 & 物件     C++ 在 C 語言的基礎上增加了面向物件程式設計，C++ 支援面向物件程式設計。類是 C++ 的核心特性，通常被稱為使用者定義的型別。     類用於指定物件的形式，它包含了資料表示法和用於處理資料的方法。類中的資料和方法稱為類的成員。函式在

c++中類的預設四個成員函式介紹（建構函式+拷貝構造+解構函式+賦值運算子過載函式）

在C++中，類的6個預設的成員函式包括： 建構函式、解構函式、拷貝建構函式、賦值運算子過載函式、取地址操作符過載、const修飾的取地址操作符過載。 本文將主要介紹前四個成員函式： 一、建構函式 在c++程式中，物件的初始化時一個不可缺少且十分重要的

C++中基類的解構函式為什麼要用virtual虛解構函式【轉】

（轉自：https://blog.csdn.net/iicy266/article/details/11906457） 知識背景          要弄明白這個問題，首先要了解下C++中的動態繫結。&n

C++---之帶有virtual的解構函式概念

C++解構函式加上virtual是為了防止記憶體洩漏。 用在C++實現多型的時候，其基類要加virtual。   原因跟動態繫結有關，大家都知道，多型是通過虛擬函式實現的，而虛擬函式又是通過動態繫結實現的。 先舉個例子： class Base {

淺談C++類（7）--解構函式

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

C++中為什麼要將解構函式定義成虛擬函式

      派生類的成員由兩部分組成，一部分是從基類那裡繼承而來，一部分是自己定義的。那麼在例項化物件的時候，首先利用基類建構函式去初始化從基類繼承而來的成員，再用派生類建構函式初始化自己定義的部分。 同時，不止建構函式派生類只負責自己的那部分，解構函式也是，所以派生

C++中基類的解構函式為什麼要用virtual虛解構函式

知識背景          要弄明白這個問題，首先要了解下C++中的動態繫結。  正題          直接的講，C++中基類採用virtual虛解構函式是為了防止記憶體洩漏。具體地說，如果派生類中申請了記憶體空間，並在其解構函式中對這些記憶體空間進行釋放

為什麼建構函式不能為虛擬函式，而解構函式可以為虛擬函式？

1. 為什麼建構函式不能為虛擬函式？    虛擬函式的呼叫需要虛擬函式表指標，而該指標存放在物件的內容空間中；若建構函式宣告為虛擬函式，那麼由於物件還未建立，還沒有記憶體空間，更沒有虛擬函式表地址用來呼叫虛擬函式——構造函數了。 2. 為什麼解構函式可以為虛擬函式，如果不

C++學習之多型篇（虛擬函式和虛解構函式的實現原理--虛擬函式表）

通過下面的程式碼來說明： #include <iostream> #include <stdlib.h> #include <string> using namespace std; /**  *  定義動物類：Animal  *  成員

C++多型及虛解構函式

C++實現多型 多型：支援相關的物件具有不同的成員函式(但原型相同) ，並允許物件與適當的成員函式進行執行時繫結。 虛表和虛表指標介紹 當呼叫一個虛擬函式時，被執行的程式碼必須與

拷貝建構函式執行後解構函式呼叫兩次出錯問題

#ifndef FILENAME #define FILENAME int k=10; class Oblong { public: void out_area() const; //宣告計算面積函式 Oblong()

深入探索C++物件模型(九) 解構函式 （以及顯式定義的解構函式問題、解構函式Rules of Three）

  如果類沒有定義解構函式，那麼只有類中含有成員物件（或者本類的基類）擁有解構函式的情況下，編譯器才會合成一個出來，否則解構函式被視為不要，也就不需要合成。例如，如下類，雖然Point類擁有虛擬函式：class Point {  piblic:       Point(flo

為什麼必須實現虛解構函式 ,純虛解構函式的原因

本文的主要參考書籍是  C++ Primer struct A { virtual ~A() = 0; }; struct B : A { virual ~B() {} }; int main( void ) { B x; } 編譯的時候

將解構函式設定為虛擬函式，並且解構函式可以為純虛擬函式

為什麼基類的解構函式是虛擬函式？ 　　在實現多型時，當用基類操作派生類，在析構時防止只析構基類而不析構派生類的狀況發生。 但如果不需要基類對派生類及物件進行操作,則不能定義虛擬函式,因為這樣會增加記憶體開銷.當類裡面有定義虛擬函式的時候,編譯器會給類新增一個虛擬函式表,裡面

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

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

C++基礎：類與物件(物件呼叫成員函式 this指標)

1.一個物件的this指標並不是物件本身的一部分，不會影響sizeof(物件)的結果。this作用域是在類內部，當在類的非靜態成員函式中訪問類的非靜態成員的時候，編譯器會自動將物件本身的地址作為一個隱含引數傳遞給函式。也就是說，即使你沒有寫上this指標，編譯器在編譯的時候

this指標在普通函式、物件方法、定時器、建構函式、事件函式、call()、apply()中的執行

前導： this是JavaScript中的一個關鍵字，在不同的場景中，this指向的物件也不同。在其他面嚮物件語言中（如C#），this就是指向當前物件。而在JavaScript 中this是在程式碼執行時繫結的，相對而言this指向比較混亂。在程式碼執行時th

Day7 建構函式 this指標 static修飾符

建構函式特點 1 函式名與類名一致 2不用寫返回型別 3 沒有具體返回值作用 給物件初始化 注意 多個建構函式是以過載的形式存在呼叫順序1 mian入棧 2建立p2物件開闢地址 3person(n,a)建構函式入棧並賦值4 傳給給堆裡的資料 初始化完畢 5 把堆裡資料的