2. 程式人生 > >5.2-day02-C++/內聯/動態記憶體分配/引用/顯示型別轉換

5.2-day02-C++/內聯/動態記憶體分配/引用/顯示型別轉換

阿新 • • 發佈：2018-11-29
九、 3.內聯 1)編譯器用函式的二進位制程式碼替換函式呼叫語句，減少函式呼叫的時間開銷。這種優化策略成為內聯。 2)頻繁呼叫的簡單函式適合內聯，而稀少呼叫的複雜函式不適合內聯。 3)遞迴函式無法內聯。 4)通過inline關鍵字，可以建議編譯對指定函式進行內聯，但是僅僅是建議而已。 inline void foo (int x, int y){...} 十、C++的動態記憶體分配 malloc/calloc/realloc/free 1.new/delete：對單個變數進行記憶體分配/釋放 2.new[ ]/delete[ ]：對陣列進行記憶體分配/釋放 十一、引用 1.引用即別名。 int a = 20; int& b = a; // int* b = &a;     引用的本質就是指標 。 b = 10; // *b = 10; cout << a << endl; // 10  2.引用必須初始化。 int a; int* p; a = 20; p = &a; int& b; // ERROR ! int& b = a; // OK 3.引用一旦初始化就不能再引用其它變數。 int a = 20, c = 30; int& b = a; b = c; // c => b/a 4.引用的應用場景 1)引用型引數 a.修改實參 b.避免拷貝，通過加const可以防止在函式中意外地修改實參的值，同時還可以接受擁有常屬性的實參。 2)引用型返回值 int b = 10; int a = func (b); func (b) = a; 從一個函式中返回引用往往是為了將該函式的返回值作為左值使用。但是，一定要保證函式所返回的引用的目標在該函式返回以後依然有定義，否則將導致不確定的後果。 不要返回區域性變數的引用，可以返回全域性、靜態、成員變數的引用，也可以返回引用型形參變數本身。 5.引用和指標 1)引用的本質就是指標，很多場合下引用和指標可以互換。 2)在C++層面上引用和指標存在以下不同： A.指標式實體變數，但是引用不是實體變數。 int& a = b; sizeof (a); // 4 double& d = f; sizeof (d); // 8 B.指標可以不初始化，但是引用必須初始化。 C.指標的目標可以修改，但是引用的目標的不能修改。 D.可以定義指標的指標，但是不能定義引用的指標。 int a; int* p = &a; int** pp = &p; // OK int& r = a; int&* pr = &r; // ERROR E.可以定義指標的引用，但是不能定義引用的引用。 int a; int* p = &a; int*& q = p; // OK int& r = a; int&& s = r; // ERROR F.可以定義指標的陣列，但是不能定義引用的陣列。 int a, b, c; int* parr[] = {&a, &b, &c}; // OK int& rarr[] = {a, b, c}; // ERROR 可以定義陣列的引用。 int arr[] = {1, 2, 3}; int (&arr_ref)[3] = arr; // OK 十二、顯示型別轉換運算子 C：目標型別變數 = (目標型別)源型別變數； 1.靜態型別轉換 static_cast<目標型別> (源型別變數) 如果在目標型別和源型別之間某一個方向上可以做隱式型別轉換，那麼在兩個方向上都可以做靜態型別轉換。反之如果在兩個方向上都不能做隱式型別轉換，那麼在任意一個方向上也不能做靜態型別轉換。 int* p1 = ...; void* p2 = p1; p1 = static_cast<int*> (p2); char c; int i = c; 如果存在從源型別到目標型別的自定義轉換規則，那麼也可以使用靜態型別轉換。 2.動態型別轉換 dynamic_cast<目標型別> (源型別變數) 用在具有多型性的父子類指標或引用之間。 3.常型別轉換 const_cast<目標型別> (源型別變數) 給一個擁有const屬性的指標或引用去常 const int a = 100; const int* p1 = &a; *p1 = 200; // ERROR int* p2 = const_cast<int*> (p1); *p2 = 200; // OK 4.從解釋型別轉換 reinterpret_cast<目標型別> (源型別變數); 在不同型別的指標或引用之間做型別轉換，以及在指標和整型之間做型別轉換。 5.目標型別變數 = 目標型別(源型別變數)； int a = int (3.14); 十三、C++之父的建議 1.少用巨集，多用const、enum和inline #define PAI 3.141519 const double PAI = 3.14159; #define ERROR_FILE -1 #define ERROR_MEM  -2 enum {   ERROR_FILE = -1,   ERROR_MEM = -2 }; #define max(a,b) ((a)>(b)?(a):(b)) inline int double max (double a, double b) {   return a > b ? a : b; } 2.變數隨用隨宣告同時初始化。 3.少用malloc/free，多用new/delete。 4.少用C風格的強制型別轉換，多用型別轉換運算子。 5.少用C風格的字串，多用string。 6.樹立面向物件的程式設計思想。 ++C 第二課  類和物件 一、什麼是物件 1.萬物皆物件 2.程式就是一組物件，物件之間通過訊息交換資訊 3.類就是對物件的描述和抽象，物件就是類的具體化和例項化 二、通過類描述物件 屬性：姓名、年齡、學號 行為：吃飯、睡覺、學習 類就是從屬性和行為兩個方面對物件進行抽象。 三、面向物件程式設計(OOP) 現實世界                 虛擬世界 物件    -> 抽象 -> 類 -> 物件 1.至少掌握一種OOP程式語言 2.精通一種面向物件的元語言—UML 3.研究設計模式，GOF 四、類的基本語法 1.類的定義 class 類名 { }; 如 class Student { }; 2.成員變數——屬性 class 類名 {   型別 成員變數名; }; 如 class Student {   string m_name;   int    m_age; }; 3.成員函式——行為 class 類名 {   返回型別 成員函式名 (形參表) {     函式體;   } }; 如 class Student {   string m_name;   int    m_age;   void eat (const string& food) {     ...   } }; 4.訪問控制屬性 1)公有成員：public，誰都可以訪問。 2)私有成員：private，只有自己可以訪問。 3)保護成員：protected，只有自己和自己的子類可以訪問。 4)類的成員預設訪控屬性為私有，而結構的成員預設訪控屬性為公有。
1.c 
    
    
     
  1. #include
     
     <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. int main (void) {
    4. 
     
  4. 	cout << "Hello, World !" << endl;
    5. 
     
  5. 	return 0;
    6. 
     
  6. }
    7.
 
1.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. int main (void) {
    4. 
     
  4. 	auto i 
     
    = 10;
    5. 
     
  5. 	auto f = 3.14;
    6. 
     
  6. 	cout << i << ' ' << f << endl;
    7. 
     
  7. 	return 0;
    8. 
     
  8. }
    9.
 用2011編譯器去編譯；  g++ 11.cpp -std=c++0x
const.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. int main (
     
    void) {
    4. 
     
  4. 	const volatile int a = 100;
    5. 
     
  5. //	a = 200;
    6. 
     
  6. 	const volatile int* p1 = &a;
    7. 
     
  7. //	*p1 = 200;
    8. 
     
  8. 	int* p2 = const_cast<int*> (p1);
    9. 
     
  9. 	*p2 = 200;
    10. 
     
  10. 	cout << *p2 << endl; // 200
    11. 
     
  11. 	cout << a << endl; // 200
    12. 
     
  12. 	// cout << 100 << endl;
    13. 
     
  13. 	return 0;
    14. 
     
  14. }
    15.
  強制型別轉換：放棄一切安全機制；   目標型別變數=（目標型別） 源型別變數；  C++編譯器：靜態編譯器；  靜態：static_cast  動態：dynamic_cast
【給一個擁有const屬性的指標或引用去常，去掉常屬性】   const 只讀屬性；     const int a = 100;   //常量優化 不管a是多少，a都為100，打出a的字面值，用100去優化；
const volatile int a = 100;  別做優化，會用a的值輸出；  用volatile保證不做暫存器優化，常量優化的值； 保證訪問的是記憶體中的值，而不是歷史值；  new返回的是陣列的首地址；
new.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. int main (void) {
    4. 
     
  4. //	int* pi = (int*)malloc (sizeof (int));
    5. 
     
  5. //	free (pi);
    6. 
     
  6. 	int* pi = new int;
    7. 
     
  7. 	*pi = 1000;
    8. 
     
  8. 	cout << *pi << endl;
    9. 
     
  9. 	delete pi;
    10. 
     
  10. 	pi = NULL;
    11. 
     
  11. 	/*
    12. 
     
  12. 	*pi = 2000;
    13. 
     
  13. 	cout << *pi << endl;
    14. 
     
  14. 	*/
    15. 
     
  15. 	pi = new int[10];
    16. 
     
  16. 	for (size_t i = 0; i < 10; ++i)
    17. 
     
  17. 		pi[i] = i;
    18. 
     
  18. 	for (size_t i = 0; i < 10; ++i)
    19. 
     
  19. 		cout << pi[i] << ' ';
    20. 
     
  20. 	cout << endl;
    21. 
     
  21. 	delete[] pi;
    22. 
     
  22. 	pi = NULL;
    23. 
     
  23. 	pi = new int (1234);
    24. 
     
  24. 	cout << *pi << endl;
    25. 
     
  25. 	delete pi;
    26. 
     
  26. 	pi = NULL;
    27. 
     
  27. 	char buf[4] = {0x12,0x34,0x56,0x78};
    28. 
     
  28. 	pi = new (buf) int;
    29. 
     
  29. 	cout << hex << *pi << endl;
    30. 
     
  30. //	delete pi;
    31. 
     
  31. 	cout << (void*)pi << ' ' << (void*)buf << endl;
    32. 
     
  32. 	int (*p)[4] = new int[3][4];
    33. 
     
  33. 	delete[] p;
    34. 
     
  34. 	int (*q)[4][5] = new int[3][4][5];
    35. 
     
  35. 	delete[] q;
    36. 
     
  36. 	return 0;
    37. 
     
  37. }
    38.
 new/delete:對單個變數進行記憶體分配/釋放；  new[]/delete[]:對陣列進行記憶體分配/釋放；   new  int[3][4]  返回的是一個二維陣列第一個元素的地址；
三維陣列：二維陣列的陣列 int (*p) [4] = new   int [3][4]; 用二維陣列的指標去接受三維陣列；   
動態記憶體分配： string自動維護記憶體，無記憶體限制； “\0”，且自動新增 ‘\0’
對單個變數：   對陣列：  malloc在堆裡釋放記憶體，只malloc不free， 稱為記憶體的洩露；    int  *pi = new int;   new:對單個變數進行記憶體的分配；   野指標：存著一個地址，但裡面標識的記憶體已經被釋放；      以陣列方式new的，要用delete[] 刪掉；   pi = new int [10];  ......delete[] pi;     delete    pi;   區域性釋放   delete[ ] pi;  全部釋放     pi = new int (1234);    new的同時賦初值； 棧記憶體不能delete;  pi = new (buf)int;        以buf為首的，int大小區域；
reinter.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. int main (void) {
    4. 
     
  4. int i = 0x12345678;
    5. 
     
  5. 	char* p = reinterpret_cast<char*> (&i);
    6. 
     
  6. 	for (size_t i = 0; i < 4; ++i)
    7. 
     
  7. 		cout << hex << (int)p[i] << ' ';
    8. 
     
  8. 	cout << endl;
    9. 
     
  9. 	float* q = reinterpret_cast<float*> (&i);
    10. 
     
  10. 	cout << *q << endl;
    11. 
     
  11. 	void* v = reinterpret_cast<void*> (i);
    12. 
     
  12. 	cout << v << endl;
    13. 
     
  13. 	return 0;
    14. 
     
  14. }
    15.
 reinterpret_cast <> (  ) //重解釋型別轉換-同一個記憶體，從不同角度（不同指標型別去看），對風馬牛不相及的指標進行轉化；

retref.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. int g_data = 100;
    4. 
     
  4. int& foo (void) {
    5. 
     
  5. 	return g_data;
    6. 
     
  6. }
    7. 
     
  7. int& bar (void) {
    8. 
     
  8. 	int a = 100;
    9. 
     
  9. 	return a;
    10. 
     
  10. }
    11. 
     
  11. int& fun (void) {
    12. 
     
  12. 	int b = 200;
    13. 
     
  13. 	return b;
    14. 
     
  14. }
    15. 
     

    16. 
     
  16. int& hum (int& a) {
    17. 
     
  17. 	return a;
    18. 
     
  18. }
    19. 
     
  19. int main (void) {
    20. 
     
  20. 	int data = foo ();
    21. 
     
  21. 	cout << data << endl; // 100
    22. 
     
  22. 	foo () = 200;
    23. 
     
  23. 	cout << g_data << endl;
    24. 
     
  24. 	foo () += 100;
    25. 
     
  25. 	++foo ();
    26. 
     
  26. 	cout << g_data << endl; // 301
    27. 
     
  27. 	int& a = bar ();
    28. 
     
  28. 	fun ();
    29. 
     
  29. 	cout << a << endl; // 200
    30. 
     
  30. 	return 0;
    31. 
     
  31. }
    32.
          int b = 10;   int a = func(b);     返回右值；   func(b) = a;          返回左值；     foo ( ) = 200;    //200賦給臨時變數；
  int & foo (void) {    return g_data;    }    // 200賦給g_data了，此時賦的是別名int & foo (void);
static.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. int main (void) {
    4. 
     
  4. 	int* p1 = NULL;
    5. 
     
  5. 	void* p2 = p1;
    6. 
     
  6. 	p1 = static_cast<int*> (p2);
    7. 
     
  7. 	return 0;
    8. 
     
  8. }
    9.
指標p2進行靜態型別轉換：  p1 = static_cast<int*> (p2);  
  string.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. #include <cstring>
    3. 
     
  3. #include <cstdio>
    4. 
     
  4. using namespace std;
    5. 
     
  5. int main (void) {
    6. 
     
  6. 	string s1 ("hello");
    7. 
     
  7. 	string s2 = "world";
    8. 
     
  8. 	(s1 += " ") += s2;
    9. 
     
  9. 	cout << s1 << endl;
    10. 
     
  10. 	string s3 = s1;
    11. 
     
  11. 	cout << s3 << endl;
    12. 
     
  12. 	cout << (s1 == s3) << endl;
    13. 
     
  13. 	s3[0] = 'H';
    14. 
     
  14. 	cout << s3 << endl;
    15. 
     
  15. 	cout << (s1 > s3) << endl;
    16. 
     
  16. 	cout << s1.length () << endl;
    17. 
     
  17. 	cout << (s1 == s3) << endl;
    18. 
     
  18. 	
    19. 
     
    20. 
     
  20. 
        
         cout << (strcasecmp (s1.c_str (),
        
        
                 s3.c_str ()) == 0) << endl;
        	cout << sizeof (s1) << endl;
    21. 
     
  21. 	FILE* fp = fopen ("string.txt", "w");
    22. 
     
  22. //	fwrite (&s3, sizeof (s3), 1, fp);
    23. 
     
  23. 	fwrite (s3.c_str (), sizeof (char),
    24. 
     
  24. 		s3.length (), fp);
    25. 
     
  25. 	fclose (fp);
    26. 
     
  26. 	return 0;
    27. 
     
  27. }
    28.
 
  1. cout << (strcasecmp (s1.c_str (),
  2. s3.c_str ()) == 0) << endl;
 不區分大小寫進行比較，因為要求用char型別，所以用s1.c_str()和s3.c_str（）
student.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. class Student {
    4. 
     
  4. private:
    5. 
     
  5. 	string m_name;
    6. 
     
  6. 	int m_age;
    7. 
     
  7. public:
    8. 
     
  8. 	void eat (const string& food) {
    9. 
     
  9. 		cout << m_age << "歲的" << m_name
    10. 
     
  10. 			<< "同學正在吃" << food << "。" << endl;
    11. 
     
  11. 	}
    12. 
     
  12. 	void setName (const string& name) {
    13. 
     
  13. 		if (name == "2")
    14. 
     
  14. 			cout << "你才" << name << "！" << endl;
    15. 
     
  15. 		else
    16. 
     
  16. 			m_name = name;
    17. 
     
  17. 	}
    18. 
     
  18. 	void setAge (int age) {
    19. 
     
  19. 		if (age < 0)
    20. 
     
  20. 			cout << "無效的年齡！" << endl;
    21. 
     
  21. 		else
    22. 
     
  22. 			m_age = age;
    23. 
     
  23. 	}
    24. 
     
  24. };
    25. 
     
  25. int main (void) {
    26. 
     
  26. 	Student student;
    27. 
     
  27. 	student.setName ("2");
    28. 
     
  28. 	student.setAge (-100);
    29. 
     
  29. 	student.setName ("張飛");
    30. 
     
  30. 	student.setAge (20);
    31. 
     
  31. 	student.eat ("包子");
    32. 
     
  32. 	return 0;
    33. 
     
  33. }
    34.


swap.cpp 
    
    
     
  1. #include <iostream>
    2. 
     
  2. using namespace std;
    3. 
     
  3. void swap1 (int a, int b) {
    4. 
     
  4. 	int c = a;
    5. 
     
  5. 	a = b;
    6. 
     
  6. 	b = c;
    7. 
     
  7. }
    8. 
     
  8. void swap2 (int* a, int* b) {
    9. 
     
  9. 	int c = *a;
    10. 
     
  10. 	*a = *b;
    11. 
     
  11. 	*b = c;
    12. 
     
  12. }
    13. 
     
  13. void swap3 (int& a, int& b) {
    14. 
     
  14. 	int c = a;
    15. 
     
  15. 	a = b;
    16. 
     
  16. 	b = c;
    17. 
     
  17. }
    18. 
     
  18. void swap4 (const char* x, const char* y) {
    19. 
     
  19. 	const char* z = x;
    20. 
     
  20. 	x = y;
    21. 
     
  21. 	y = z;
    22. 
     
  22. }
    23. 
     
  23. void swap5 (const char** x, const char** y) {
    24. 
     
  24. 	const char* z = *x;
    25. 
     
  25. 	*x = *y;
    26. 
     
  26. 	*y = z;
    27. 
     
  27. }
    28. 
     
  28. void swap6 (const char*& x, const char*& y) {
    29. 
     
  29. 	const char* z = x;
    30. 
     
  30. 	x = y;
    31. 
     
  31. 	y = z;
    32. 
     
  32. }
    33. 
     
  33. struct Student {
    34. 
     
  34. 	char name[1024];
    35. 
     
  35. 	int age;
    36. 
     
  36. };
    37. 
     
  37. void print (const struct Student& s) {
    38. 
     
  38. 	cout << s.name << "，" << s.age << endl;
    39. 
     
  39. //	s.age = -1;
    40. 
     
  40. }
    41. 
     
  41. void foo (const int& x) 
    42. 
     
  42. 	cout << x << endl;
    43. 
     
  43. }
    44. 
     
  44. int main (void) {
    45. 
     
  45. 	int a = 100, b = 200;
    46. 
     
  46. //	swap1 (a, b);
    47. 
     
  47. //	swap2 (&a, &b);
    48. 
     
  48. 	swap3 (a, b);
    49. 
     
  49. 	cout << a << ' ' << b << endl; // 200 100
    50. 
     
  50. 	const char* x = "hello", *y = "world";
    51. 
     
  51. //	swap4 (x, y);
    52. 
     
  52. //	swap5 (&x, &y);
    53. 
     
  53. 	swap6 (x, y);
    54. 
     
  54. 	cout << x << ' ' << y << endl;
    55. 
     
  55. 	Student s = {"張飛", 22};
    56. 
     
  56. 	print (s);
    57. 
     
  57. 	print (s);
    58. 
     
  58. 	foo (100);
    59. 
     
  59. 	return 0;
    60. 
     
  60. }
    61.
 引用：  swap3 (a, b);     -> void swap3 (int& a, int& b)  {......}
指標：
void swap5 (const char** x, const char** y) 要用二級指標，即，const char ** x 
引用型引數： void print ( const struct Student & s )
&符號避免拷貝的開銷；提高了效率；  避免拷貝，通過加const可以防止在函式中意外地修改實參的值，  同時還可以接受擁有常屬性的實參。









來自為知筆記(Wiz)

相關推薦

5.2-day02-C++/內聯/動態記憶體分配/引用/顯示型別轉換

九、 3.內聯 1)編譯器用函式的二進位制程式碼替換函式呼叫語句，減少函式呼叫的時間開銷。這種優化策略成為內聯。 2)頻繁呼叫的簡單函式適合內聯，而稀少呼叫的複雜函式不適合內聯。 3)遞迴函式無法內聯。 4)通過inline關鍵字，可以建議

C++ 模板類動態記憶體分配

總時間限制:  1000ms   記憶體限制:  65536kB // 在此處補充你的程式碼 描述 程式填空，輸出指定結果 #include <iostream> #include <string> #includ

【C語言】動態記憶體分配小結

為什麼存在動態記憶體分配？ 我們已經掌握的記憶體開闢方式有： int val = 20;//在棧空間上開闢四個位元組 char arr[10];//在棧空間上開闢10個位元組的連續空間 但是上面開闢空間的方式有兩個特點： 1.空間開闢的大小是固定的 2.陣列在申明的時

【C語言】動態記憶體分配（malloc,realloc,calloc,free）的基本理解和區別

#include<Windows.h> #include<stdio.h> #include<malloc.h> int main() { int* p = NULL; printf("%x\n", p); p = (int*)malloc(sizeof(int)*

C語言之動態記憶體分配與釋放

一，堆記憶體 1,堆記憶體特點 堆記憶體可以存放任意型別的資料，但需要自己申請與釋放。 2，堆大小 堆大小，想像中的無窮大，但實際使用中，受限於實際記憶體的大小和記憶體是否有連續性。 二，堆記憶體的申請與釋放 1，malloc函式

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

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

關於C++中的動態記憶體分配

1.malloc()、realloc()、free()函式   這三個函式為c++標準庫中的函式，都在#include <stdlib.h>中。（1）void *malloc()的返回型別為空指標 void *,因為我們並不知道指標指向什麼型別的資料，所以用voi

c++學習筆記 動態記憶體分配 物件、物件陣列的動態建立和釋放

宣告：註明程式碼 出處http://www.weixueyuan.net/view/6347.html 當我們需要為類物件動態分配儲存空間時，我們應該使用C++語言提供的new與new[]操作符，而不要使用C語言提供的malloc函式。 C++語言提供的new和new[

C++ 內聯函數

c++ inline 內聯函數內聯函數和普通函數的區別：普通函數在內存上只有一份，任何地方在調用她的時候分3步：①：找出這個函數②：執行此內聯函數③：返回結果（可以是void），結束此函數，繼續執行此函數下面的代碼但是內聯函數的調用步驟和不同函數是以一樣的 ， 因為他在編譯的時候就不一樣：如何編譯：如果此函數

C++內聯函數

程序執行效率 一定的 由於 turn name 系統 定義 函數聲明 sin 調用函數時需要一定的時間和空間的開銷。C++提供一種提高效率的方法，即在編譯時將函數調用處用函數體替換，類似於C語言中的宏展開。這種在函數調用處直接嵌入函數體的函數稱為內聯函數（inline fu

學習筆記-C語言6（指標與動態記憶體分配）

1. 指標 指標的引入： 指標是C語言最強大的功能之一，使用指標可以儲存某個變數在記憶體中的地址，並且通過操作指標來對該片記憶體進行靈活的操作，例如改變原變數的值，或者構造複雜的資料結構。指標一般初始化為NULL（0）。& 是取地址運算，* 是間接運算子，通過 * 可以訪問與修改

C++內聯（inline）函式

        行內函數的格式：inline 返回值型別  函式名（引數）  如：inline void display(int r); 一、為什麼要用行內函數 &n

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

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

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

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

C++ primer筆記----動態記憶體

1、 物件生命週期：全域性物件在程式啟動時分配，在程式結束時銷燬。區域性自動物件，當我們進入其定義所在程式塊時被建立，在離開塊時被銷燬。區域性static物件在第一次使用前分配，在程式結束時銷燬 2、除了static和自動物件外，C++還支援動態物件的分配。動態分配的物件的生存期與它們在

C++二維陣列動態記憶體分配【轉】

（轉自：https://www.cnblogs.com/Forever-Kenlen-Ja/p/3753566.html）   /*申請3行4列的二維陣列記憶體*/ int **array; array = new int *[3];/*先申請3個int*型

連結串列的C語言實現 含動態記憶體分配

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

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

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

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

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

C++ 二維陣列動態記憶體分配過載以及拷貝構造

總時間限制:  1000ms   記憶體限制:  65536kB // 在此處補充你的程式碼 描述 寫一個二維陣列類 Array2,使得下面程式的輸出結果是： 0,1,2,3, 4,5,6,7, 8,9,10,11, next