Pointers

• 在C++中，電腦的記憶體就像一個個的區塊(byte)，每個區塊有固定的位址(address)，程式可以直接操控一塊記憶體( memory cells with consecutive addresses >> 可以超過1 byte)。

Address-of operator (&)

• 每個變數接儲存在電腦的某一塊記憶體內，該記憶體有特定位址。
• 將&加在某變數名稱，變成表示該變數的位址，否則只表示該變數的值。e.g.
#include <iostream> using namespace std; int main() { int a = 10; int &add_a = a; int val = a; cout << "a = " << a << "\tval = " << val << endl; cout << "Address of a = " << &add_a << "\tValue contained in &add_a = " << add_a << endl; add_a = 20; val = 100; cout << "a = " << a << "\tval = " << val << endl; cout << "Address of a = " << &add_a << "\tValue contained in &add_a = " << add_a << endl; return 0; }
• 此例中&add_a表示變數a在記憶體的位址，而add_a則表示該位址所儲存的值(也就是a)，當add_a被改變時，a也隨之改變(反之亦然)，因為是指的同一塊記憶體。
• 而val=a;則表示val得到a的值的copy，但是val與a分別儲存在兩塊不同的記憶體。
• 在取得某變數的reference時，兩者必須有相同的type(e.g. 皆為int)，若有const修飾，則兩者皆須有const修飾(e.g. const int a = 10; const int &add_a = a;)。
• 可以refer to常數，但是必須使用const修飾，e.g. const int &add_a1 = 50;。

Dereference operator (*)

• 儲存某一變數(或物件)的位址的變數稱為pointer。
• 將*加在某變數之前，表示該變數為pointer，指向被指派的變數。e.g.
#include <iostream> using namespace std; int main() { int x = 10; int *y = &x; cout << "x = " << x << "\ty = " << y << "\t*y = " << *y <<endl; return 0; }
• 變數y儲存變數x的位址，在宣告pointer時，還是使用要指向的資料的資料型態(除非是void)。
• *y則表示該位址的值，因為去除了指位來取得值，因此稱為dereference，所以*&x指的便是x。
• 之前提的是變數，若是Array的pointer用法如下:
#include <iostream> using namespace std; int main() { int x[5] = {1,2,3,4,5}; int *y; y = x; // *y = x[0] *y = 10; y = &x[1]; // *y = x[1] *y = 20; y = x + 2; // *y = x[2] *y = 30; y = &x[0]; // equivalent to y = x *(y+3) = 40; // *(y+3) = x[3] *(x+4) = 50; for(int i = 0; i < 5; i++) cout << x[i] << " "; return 0; }
• int *y宣告y是pointer變數，而y=x則為y=&x[0]的簡寫。
• pointer y可以指向其他位址，例如y = &x[1];此時y指向&x[1]。
• y = x + 2;表示自x[0]平移兩位，所以是指向x[2]。
• *(y+3)表示自原指位位址平移三位。
• 由上可知pointer可使用+號來表示往後移動多少塊記憶體(以快為單位，實際長度是資料型態而定)。所以可以如下印出array內容(若使用*y++表示指標往後指一位)。
#include <iostream> using namespace std; int main() { int x[5] = {1,2,3,4,5}; int *y; y = x; for(int i = 0; i < 5; i++) cout << *y+i << " "; // cout << *y++ << " "; return 0; }
• 請注意*y++相當於(*y)++或*(y++)，但若是使用++*y或++(*y)則表示*y每次加1，所以會印出2,3,4,5,6(但是都指向同一塊記憶體，也就是x[0])。若是使用*++y則表示y先加1再顯示值，這樣會跳過x[0]，但是最後會去取x[5]的值，但x[5]已經超出array的範圍。
• 字串可視為字元的array，所以也可以如下操作。
#include <iostream> using namespace std; int main() { char s[]="Hello!"; char *y = s; for(int i = 0; i < 6; i++){ cout << *y++ << endl; } return 0; }
• pointer是記憶某記憶體的位置，但此資料也是儲存在某記憶體內，在C++中也可以取得變數記憶體位置的記憶體位置，使用兩個*號表示。
#include <iostream> using namespace std; int main() { int x = 10; int *y = &x; int **z = &y; cout << x << "\t" << y << "\t" << z << endl; cout << *y << "\t" << *z << "\t" << **z << endl; return 0; }
• z所儲存的是y的記憶體位址，而y所儲存的是x的記憶體位址。
• *z為y所表示的位址(也就是&x)，**z則再dereference一次，變成y所指向位址的值(*y)，也就是x。
• 先前提到宣告pointer其形態需與被指為資料的型態相同，但若是void則為例外，也就是void的pointer指向一個型態未知的記憶體區塊。此記憶體在給值後，可以cast給另一個pointer，再使用此pointer來顯示值，這個特性可以用來設計不確定型態的函數(generic)。
#include <iostream> using namespace std; int main() { int x = 10; void *v = &x; cout << v << endl;// CANNOT print *v int *p = (int*)v; ++*p; cout << *p << endl; return 0; }
• v是void pointer，當int x的位址指派給*v後，可以取得v的位址，但是*v無法取得。
• 使用int *p = (int*)v;將v cast成為int，指派給*p，此時可以印出*p。
• pointer可以用在呼叫函數，語法是在函數名之前加上*號然後整個括號起來，後面加上需輸入的參數型態。
#include <iostream> #include <cmath> using namespace std; double CircleArea(double r){ return M_PI*r*r; } double CirlcleCircumference(double r){ return 2*M_PI*r; } double Circle(double r, double (*call)(double)){ double result = (*call)(r); return result; } int main() { int r = 10; double (*perimeter)(double) = CirlcleCircumference; cout << Circle(r, CircleArea) << endl; cout << Circle(r, perimeter) << endl; return 0; }
• double (*call)(double)同為CircleArea()與CirlcleCircumference()的型態，所以只要傳入call的名稱與其中之一相同，表示將使用該函數。
• double (*perimeter)(double) = CirlcleCircumference;表示將原來CirlcleCircumference名稱改為使用perimeter代替。
• 若是pointer指向物件，pointer可以直接使用使用->符號使用物件內容。
#include <iostream> #include <cmath> using namespace std; class Circle{ double radius; // variable public: Circle(double r){radius = r;}; // constructor double area(){ // method return radius*radius*M_PI; }; }; int main() { Circle c1 = 10; // instance Circle c2 = 100; Circle c3 = 1000; Circle circles[] = {c2, c3}; Circle *p = &c1; cout << (*p).area() << "\n" << c1.area() << endl; Circle *ps = circles; cout << ps[0].area() << endl; cout << ps[1].area() << endl; return 0; }
• p->area()等同於(*p).area() or c1.area()。
• 若是物件所組成的array，則用法與之前提到的array相同，使用Circle *ps = circles;將整個array指派給ps，然後使用ps[index]來取得在index位置的物件。原則上就等於circles[index]。

Dynamic memory

• 在某些情況下，程式所需要的記憶體大小無法確認，此時可以配置動態記憶體。
• 使用關鍵字new將記憶體配置給pointer變數，在使用完之後，需要將記憶體釋放，歸還給系統，此時需使用delete關鍵字。
#include <iostream> #include <cmath> using namespace std; int main() { int *p = new int(100); cout << p << "\t" << *p << endl; p++; cout << p << "\t" << *p << endl; delete p; return 0; }
• 系統配置一塊int大小的記憶體給p，並給初值100。這樣就不用先宣告一個int，在取得位址(&)，然後指派給p。
• new會配置記憶體，所以要指派給pointer變數。
• 之前提到array的做法是需先宣告一個已知長度的array，然後將其位址指派給一個pointer，若是不確定array長度，可以使用new。
#include <iostream> #include <cmath> using namespace std; int main() { int arraysize; cout << "Please input the size of array: " << endl; cin >> arraysize; int *a = new int[arraysize]; for(int i = 0; i < arraysize; i++){ cout << "a[" << i << "] = "; cin >> *(a+i); } for(int i = 0; i < arraysize; i++){ cout << "a[" << i << "] = " << a[i] << endl; } delete []a; return 0; }
• arraysize也可以配置成pointer，e.g. int *arraysize=new int(0);。
• 配置記憶體有可能失敗，處理方式通常可以拋出(throw)例外(bad_alloc exception)或中止程式。另一個方式是讓pointer變成null pointer，此時使用關鍵字nothrow。
#include <cmath> using namespace std; int main() { int arraysize; cout << "Please input the size of array: " << endl; cin >> arraysize; int *a = new (nothrow) int[arraysize]; if(a == nullptr) cout << "Memory allocation error." << endl; else{ for(int i = 0; i < arraysize; i++){ cout << "a[" << i << "] = "; cin >> *(a+i); } cout << "-------------------" << endl; for(int i = 0; i < arraysize; i++){ cout << "a[" << i << "] = " << a[i] << endl; } delete []a; } return 0; }
• 將(nothrow)關鍵字加在宣告pointer的new後方，之後判斷是否pointer等於nullptr，若是則表示配置失敗。
• 再來試試看2D array的做法。
#include <iostream> #include <cmath> using namespace std; int main() { int row, col; cout << "Please input the dimension of a 2D array" << endl; cin >> row >> col; int *arrPointer = new (nothrow) int[row*col]; if(arrPointer==nullptr){ cout << "Memory allocation error." << endl; }else{ for(int i = 0; i < row; i++){ for(int j = 0; j < col; j++){ cout << "[" << i << "][" << j << "] = "; cin >> *(arrPointer + col*i + j); } } cout << "--------------------" << endl; for(int i = 0; i < row; i++){ for(int j = 0; j < col; j++){ cout << "[" << i << "][" << j << "] = " << *(arrPointer + col*i + j) << endl; } } delete[] arrPointer; }//else return 0; }
• 其實就是變成1D的記憶體長度，算出每塊記憶體在2D array的位置即可。

Class

• 在設計class時使用pointer。
• destructor: 當設計class時配置了記憶體，可設計destructor，在程式結束後負責釋放記憶體。
#include <iostream> using namespace std; class Aclass{ int *x; public: Aclass(): x(new int){} // constructor, same to Aclass(){x = new int();} Aclass(const int& i){ // constructor x = new int(i); } ~Aclass(){delete x;} // destructor const int& value() const{return *x;} }; int main(){ Aclass a(100); cout << a.value() << endl; return 0; }
• destructor ~Aclass(){delete x;}用來在程式結束後刪除配置之記憶體。
• Aclass(): x(new int){}等同於Aclass(){x = new int();}。
• polymorphism。
#include <iostream> #include <cmath> using namespace std; class Animal{ public: string name; void setName (string name){ this->name=name; } }; class Dog: public Animal{ public: string call(){ return name + ": woof woof"; } }; class Cat: public Animal{ public: string call(){ return name + ": meow meow"; } }; int main(){ Dog lucky; Cat kitten; Animal *dog = &lucky; Animal *cat = &kitten; dog->setName("Lucky"); // lucky.setName("Lucky"); cat->setName("Kitten"); // kitten.setName("Kitten"); cout << lucky.call() << endl << kitten.call() << endl; return 0; }
• 此例主要要說明的是繼承而來的class與被繼承的class兩者的pointer型態是相容的(e.g. Animal *dog = &lucky;)。
• 使用dog->setName("Lucky");等同於lucky.setName("Lucky");。
• virtual members。
#include <iostream> #include <cmath> using namespace std; class Animal{ public: string name; void setName (string name){ this->name=name; } virtual string call(){return "unknown animal sound";} void getName(){ cout << this->name << endl; } }; class Dog: public Animal{ public: string call(){ return name + ": woof woof"; } }; class Cat: public Animal{ public: string call(){ return name + ": meow meow"; } }; int main(){ Dog lucky; Cat kitten; Animal unknown; Animal *dog = &lucky; Animal *cat = &kitten; Animal *ani = &unknown; dog->setName("Lucky"); cat->setName("Kitten"); ani->setName("Unknown"); cout << lucky.call() << endl << kitten.call() << endl << unknown.call() << endl; dog->getName(); cat->getName(); return 0; }
• 因為動物都會鳴叫，所以設計virtual函數call()，在繼承的class處可以覆寫此方法。
• 因為unknown animal的call()函數其實沒有使用的必要，所以可以將其設為abstract，將virtual函數修改為virtual string call()=0;即可。
• 請注意有abstract方法後，class Animal無法被宣告、使用其中的函數。但其pointer還是可以使用非virtual函數(e.g. dog->getName();)。
• 之前的例子若是繼承constructor，需使用new來配置記憶體。
#include <iostream> #include <cmath> using namespace std; class Animal{ public: string name; Animal (string name){ this->name=name; } virtual string call()=0; void getName(){ cout << this->name << endl; } }; class Dog: public Animal{ public: Dog(string name):Animal(name){} string call(){ return name + ": woof woof"; } }; class Cat: public Animal{ public: Cat(string name):Animal(name){} string call(){ return name + ": meow meow"; } }; int main(){ Animal *lucky = new Dog("Lucky"); Animal *kitten = new Cat("kitten"); cout << lucky->call() << endl << kitten->call() << endl; lucky->getName(); kitten->getName(); delete lucky; delete kitten; return 0; }
• 使用Animal *lucky = new Dog("Lucky");語法來配置記憶體，在使用後記得使用delete釋放出記憶體。