Array & Class

Array是用來儲存一組相同型態的資料，Class用來描述物件，包含相關的資料(可以不同型態)與相關方法。

Array

宣告Array時須先指名儲存資料的型態，可以給初值。

	#include <iostream>

	using namespace std;

	int main()
	{
		int arr1[5];
		int arr2[] = {1,2,3,4,5}; // int arr2[]{1,2,3,4,5}
		cout << "arr1[0] = " << arr1[0] << endl;
		arr1[0] = 10;
		cout << "arr1[0] = " << arr1[0] << endl;
		cout << "arr2[0] = " << arr2[0] << endl;
		arr2[0] = 100;
		cout << "arr2[0] = " << arr2[0] << endl;

		return 0;
	}

int arr1[5];宣告時沒有初始值，僅給定長度為5。使用arr1[0]來取得第一個元素(從0開始)，因為沒有給值，所以會印出一串不相關的數字，使用等號(=)來指派值，有值之後便可印出。
int arr2[] = {1,2,3,4,5};宣告時給定初始值，自動偵測長度為5。也可使用int arr2[]{1,2,3,4,5};來宣告。
若要traverse整個array，可使用loop。

	#include <iostream>
	#include <time.h>
	using namespace std;

	void printArray(int a[], int len){
		for(int i = 0; i < len; i++) {
			cout << a[i] << endl;
		}//for
	}

	int main()
	{
		int arr1[5];
		int arr2[]{1,2,3,4,5};
		srand(time(NULL));
		for (int i = 0; i < sizeof(arr1)/sizeof(arr1[0]); i++) {
			arr1[i] = rand()%101;
		}
		printArray(arr1, 5);
		cout << "RAND_MAX = " << RAND_MAX << endl;
		printArray(arr2, 5);
		return 0;
	}

sizeof(arr1)/sizeof(arr1[0]) or sizeof(arr1)/sizeof(int)可以計算array長度。
arr1內的值為亂數，產生隨機數的方式是rand()，會產生0到RAND_MAX之間的整數。
亂數需要給seed才會有不同亂數序列，所以使用srand(seed)函數。
為了讓每次產生都不同，seed使用時間(time(NULL))，因此要加入時間的標頭檔#include ，若是要固定產生的亂數序列，只需將seed設為定數即可，e.g. srand(1)。

若僅是要印出array內容，可以使用以下for loop寫法。

	#include <iostream>
	#include <time.h>
	using namespace std;

	int main()
	{
		int arr[5];
		srand(time(NULL));
		for(int i = 0; i < 5; i++){
			arr[i] = rand()%100;
		}//for

		for(int elem:arr)
			cout << elem << endl;
		return 0;
	}

若要產生多維陣列，可使用多個中括號來代表各個維度，例如2維陣列[rows][columns]。

	#include <iostream>
	#include <time.h>
	using namespace std;

	void print2DArray(int a[3][5], int rows, int cols){
		for(int i = 0; i < rows; i++) {
			for(int j = 0; j < cols; j++){
				cout << "[" << i << "][" << j << "] = " << a[i][j] << endl;
			}//for
			cout << "\n";
		}//for
	}

	int main()
	{
		int marr[3][5];
		srand(time(NULL));
		for(int i = 0; i < 3; i++){
			for(int j = 0; j < 5; j++){
				marr[i][j] = rand()%100;
			}//for
		}//for

		print2DArray(marr, 3, 5);
		return 0;
	}

在將多維陣列當作參數傳送時，需要給各維度的長度，所以給a[3][5]，第一個可以空白，也就是說a[][5]也可以。
若是三維陣列的參數，須至少給後面兩個維度長度，e.g. a[][3][5]。

原則上字串是字元的陣列，所以可以如下取得字串中字元。

	#include <iostream>

	using namespace std;

	int main()
	{
		string s = "Hello";// string s = {"Hello"};string s  {"Hello"};
		for (char elem : s)
			cout << elem << '\n';
		cout << endl;
		for(int i = 0; i < 5; i++)
			cout << s[i] << endl;
		return 0;
	}

string s = "Hello"; string s = {"Hello"};string s {"Hello"};三種宣告方式都可以。

Class

Class是物件的類別，類別內包含相關參數，建構子與對應方法。

C++的class設計有幾個地方可以有變化，以下為一個圓的class。

	#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;
		cout << c1.area() << "\t" << c2.area() << endl;
		return 0;
	}

通常命名class，第一個字母大寫。
設計圓的參數，主要為半徑。
public下的第一個函數為建構子(constructor)，是用來建構物件使用(在此須與class同名)，可在此初始化參數，之後的area為圓的方法，用來求圓面積。
在主程式中利用建構子建構圓的物件，可建立任意數量的物件，此時可以使用圓的方法來求得面積，因為計算圓面積需要使用PI，所以include資料庫cmath(#include )，然後直接使用M_PI即可。

建構子(constuctor)的建立，可以使用類似之前介紹的函數，先在class內宣告，然後在class之後完成。

	#include <iostream>
	#include <cmath>

	using namespace std;

	class Circle{
		double radius; // variable
	public:
		Circle(double); // Only need to specify the data type
		double area(){ // method
			return radius*radius*M_PI;
		};
	};

	Circle :: Circle(double r){radius = r;} // Complete the constructor here

	int main()
	{
		Circle c1 = 10; // instance
		Circle c2 = 100;
		cout << c1.area() << "\t" << c2.area() << endl;
		return 0;
	}

此處的建構子僅設計欲傳入之型態，參數的初始在之後完成。

建構子可以有超過一個，只要參數不同即可。建構子可以不設計，此時預設有一個無參數的建構子。

	#include <iostream>
	#include <cmath>

	using namespace std;

	class Circle{
		double radius; // variable
	public:
		Circle(); // first constructor
		Circle(double); // second constructor
		double area(){ // method
			return radius*radius*M_PI;
		};
	};

	Circle :: Circle(){radius = 10;} // Complete the first constructor
	Circle :: Circle(double r){radius = r;} // Complete the second constructor

	int main()
	{
		Circle c1; // instance using the first constructor
		Circle c2 = 100; // instance using the second constructor
		cout << c1.area() << "\t" << c2.area() << endl;
		return 0;
	}

此處設計兩個建構子，分別包含0跟1個參數。

建構子甚至可以使用一個函數代替，e.g.。

	#include <iostream>
	#include <cmath>

	using namespace std;

	class Circle{
		double radius; // variable
	public:
		void set_radius(double);
		double area(){ // method
			return radius*radius*M_PI;
		};
	};

	void Circle::set_radius(double r){
		radius = r;
	}

	int main()
	{
		Circle c1; // instance using the first constructor
		Circle c2; // instance using the second constructor
		c1.set_radius(10);
		c2.set_radius(100);
		cout << c1.area() << "\t" << c2.area() << endl;
		return 0;
	}

原則上set_radius()函數可以直接在class內完成 >> void set_radius(double r){radius = r;};。
在main()之內宣告物件，然後使用set_radius()方法來完成初始。
請注意class中的參數預設為private，所以無法從class外直接取得其值。

新建一個物件僅需要根據建構方式給參數值，給值的方式如下幾種都可以。

	#include <iostream>
	#include <cmath>

	using namespace std;

	class Circle{
		double radius; // variable
	public:
		Circle(double); // constructor
		double area(){ // method
			return radius*radius*M_PI;
		};
	};

	Circle::Circle(double r){
		radius = r;
	}

	int main()
	{
		Circle c1 = 10; //
		Circle c2(100); //
		Circle c3 = {1000}; //
		Circle c4{10000}; //

		cout << c1.area() << "\t" << c2.area() << "\t" << c3.area() << "\t" << c4.area() << endl;
		return 0;
	}

若要將某些運算元應用在兩個物件中，例如上例中讓c1+c2，此時+號並不是原來系統的定義(原則上如此做應該會出現錯誤)。若是要讓+號在特定物件計算有意義，需要自行定義。

	#include <iostream>

	using namespace std;

	class Vec{
		int x,y;
	public:
		Vec(){}; // constructor
		Vec(int a, int b){ // constructor
			x=a;y=b;
		}

		Vec operator+ (Vec &anotherVec){ // function that returns a Vec
			Vec temp;
			temp.setX(x + anotherVec.getX());
			temp.setY(y + anotherVec.getY());
			return temp;
		}

		bool operator == (Vec &anotherVec);

		int getX(){
			return x;
		}
		void setX(int xx){
			x = xx;
		}
		int getY(){
			return y;
		}
		void setY(int yy){
			y = yy;
		}

	};

	bool Vec::operator== (Vec &anotherVec){
		if(x == anotherVec.getX() && y == anotherVec.getY()){
			return true;
		}else
			return false;
	}

	int main(){
		Vec v1 {1,2};
		Vec v2 (3,4);
		Vec v3;
		Vec v4;
		v3 = v1 + v2;
		v4 = v1.operator+ (v2);
		cout << v3.getX() << ", " << v3.getY() << endl;
		cout << v1.operator+ (v2).getX() << ", " << v4.getY() << endl;
		cout << (v3==v4) << endl;
		return 0;
	}

class Vec有兩個變數x,y。若想要從外部使用VecObj.x與VecObj.y取得x,y，可將x,y置於public:後面一行。。
通常為了安全性，x,y還是使用private修飾較好，取得與改變x,y的值使用getters與setters方法。
Vec operator+ (Vec &anotherVec)是一個函數，重載+號的定義，當使用+號連結兩個Vec物件時的計算方式(x1+x2, y1+y2)，此函數傳入另一個Vec(&anotherVec)，傳回一個Vec(temp)。
v1 + v2;與v1.operator+ (v2);兩者都可使用，效果相同。
bool operator == (Vec &anotherVec);定義當使用==符號時的計算方式，在此只要兩個物件的x與y對應相等即視為相等，傳回true(or 1)。
可以被重載的符號包括:+ - * / = < > += -= *= /= << >> <<= >>= == != <= >= ++ -- % & ^ ! | ~ &= ^= |= && || %= [] () , ->* -> new delete new[] delete[]。

關鍵字this用來表示原物件的pointer。

	#include <iostream>

	using namespace std;

	class Vec{
		int x,y;
	public:
		Vec(){}; // constructor
		Vec(int x, int y){ // constructor
			this->x=x;this->y=y;
		}

		Vec operator+ (Vec &anotherVec){ // function that returns a Vec
			this->setX(x + anotherVec.getX());
			this->setY(y + anotherVec.getY());
			return *this;
		}

		int getX(){
			return x;
		}
		void setX(int xx){
			x = xx;
		}
		int getY(){
			return y;
		}
		void setY(int yy){
			y = yy;
		}
	};

	int main(){
		Vec v1 {1,2};
		Vec v2 (3,4);
		v1 + v2;
		cout << v1.getX() << ", " << v1.getY() << endl;
		cout << v2.getX() << ", " << v2.getY() << endl;

		return 0;
	}

此例稍微修改之前的例子。this->x=x;等號右邊的x為constructor內的local variable，而this->x則表示此物件Vec內的參數，因為this就是該物件。
在設計+號的方法內，傳回*this，因為this是該物件的pointer，所以*this為此物件的值。。
在使用的時候，v1+v2操作後因為傳回*this，所以改變的是v1的值。與之前例子不同，之前的例子是傳回另一個物件。

當class內的變數用static修飾時，表示該變數被所有衍生物件所共用。而函數被static修飾時，表示可以直接使用。

	#include <iostream>

	using namespace std;

	class Aclass{

	public:
		static int total;
		int w = 5;
		Aclass(){
			total++;
		}; // constructor
		static int add(int x, int y){
			return x+y;
			// return x+y+w; is forbidden.
		}
	};

	int Aclass::total=0;

	int main(){
		Aclass a1;
		cout << a1.total << endl;
		Aclass *a2 = new Aclass[5];
		delete a2;
		cout << Aclass::total << endl;
		cout << Aclass::add(3,6) << endl;
		return 0;
	}

被static修飾的變數，不能在class內初始化，必須在class外初始。
因為是公用的變數，所以可以直接用class name來取得它，所以可使用Aclass::total;(相當於a1.total)。
add()函數因為被static修飾，所以可以直接用Aclass::add(3,6)來取得。但是因為該函數為static，所以無法使用其他非static變數或函數(例如使用w，但是若是x+y+total則可以)。此外，也不能使用this指標。

	#include <iostream>

	using namespace std;

	class Aclass{

	public:
		int w;
		int v;
		Aclass(int w, int v){
			this->w = w;
			this->v = v;
		}; // constructor
		int add(int x, int y){
			return x+y;
		}
		int getw() const {return w;}
		const int getv() {return v;}
		const int get() const {
			return w+v;
		}
	};


	int main(){
		const Aclass a1(5,10);
		cout << a1.getw() << "\t" << a1.w << "\t" << a1.v << endl;
		// cout << a1.add(2,3) << endl; => is illegal...
		// cout << a1.getv() << endl; => is illegal...
		// a1.w = 50; => is illegal...
		const int k = a1.get();
		cout << k << endl;

		Aclass a2(20,30);
		a2.w = 50;
		cout << a2.getw() << "\t" << a2.w << "\t" << a2.getv() << "\t" << a2.v << endl;
		cout << a2.add(2,3) << endl;
		const int kk = a2.get();
		cout << kk << endl;
		return 0;
	}

當宣告物件為const時，該物件只能使用class內的const函數，若不是const物件，則都可以使用。
int getw() const表示是const函數。
const int getv()表示傳回值是const。
const int get() const表示是const函數且傳回值是const。

跟函數一樣，設計class也可以使用template。

	#include <iostream>

	using namespace std;

	template <class T>
	class Aclass{
		T values [2];
	public:
		Aclass(T one, T two){
			values[0] = one;
			values[1] = two;
		}
		T add(){
			return values[0]+values[1];
		}
		T bigger();
	};

	template <class T>
	T Aclass<T>::bigger(){
		T big = values[0] > values[1]? values[0]: values[1];
		return big;
	}

	template <>
	class Aclass<string> {
		string values [2];
	public:
		Aclass(string one, string two){
			values[0] = one;
			values[1] = two;
		}
		string concatenate(){
			string s = values[0]+values[1];
			return s;
		}

	};



	int main(){
		Aclass<int> a(1,2);
		cout << a.add() << endl;
		cout << a.bigger() << endl;
		Aclass<double> b(2.5,2.6);
		cout << b.add() << endl;
		cout << b.bigger() << endl;
		Aclass<string> c("abc","xyz");
		//cout << c.bigger() << endl; => no such a function defined.
		cout << c.concatenate() << endl;

		return 0;
	}

當要在class之外完成函數bigger()時，在之前必須再次寫template 。
template <> class Aclass與之前不同之處是根據原來的版針對某一類型物件設計class，相關函數需重新設計。

friend function指的是可以取得class內private(protected)變數的function。

	#include <iostream>
	#include <cmath>

	using namespace std;

	class Circle{
		double radius;
	public:
		Circle(){}
		Circle(double r){radius = r;}
		double area(){return M_PI*radius*radius;}
		friend Circle circlefriend(const Circle&);
	};

	Circle circlefriend(const Circle& cir){
		Circle c;
		c.radius = cir.radius;
		return c;
	}

	int main(){
		Circle c1;
		Circle c2(20);
		c1 = circlefriend(c2);
		cout << c1.area() << endl;

		return 0;
	}

friend Circle circlefriend(const Circle&);此指令使函數circlefriend成為class Circle的friend，所以可在其內取得Circle物件的private variable。

friend class與friend function類似，可以取得對方的private(protected) variable。

	#include <iostream>
	#include <cmath>

	using namespace std;

	class Circle;

	class Ellipse{
		double a, b;
	public:
		Ellipse(){}
		Ellipse(double a, double b){
			this->a=a;this->b=b;
		}
		double area(){
			return M_PI*a*b;
		}
		void convert (Circle c);
	};

	class Circle{
		friend class Ellipse;
		double radius;
	public:
		Circle(double r){radius = r;}
	};

	void Ellipse::convert(Circle c){
		a = c.radius;
		b = c.radius;
	}

	int main(){
		Ellipse e;
		Circle c(10);
		e.convert(c);
		cout << e.area() << endl;
		return 0;
	}

因為Ellipse內的convert()需要傳入Circle，所以在Ellipse之前宣告class Circle;。
在Ellipse內的convert()參數為Circle，但因為Circle尚未定義完成，所以此函數在Circle之後再完成。
在Circle內聲明其為friend of Ellipse，所以在convert()函數內，可以取得Circle內的參數radius。

C++的class之間可以繼承(Inheritance)，僅需將被繼承的class寫在classname之後的:號後面即可。

	#include <iostream>

	using namespace std;

	class Animal{

	public:
		string name;
		Animal(){name="no name";}
		Animal (string name){
			this->name=name;
		}
	};

	class Dog: public Animal{
	public:
		Dog(string name){}
		string sound(){
			return name + ": woof woof";
		}
	};

	class Cat: public Animal{
	public:
		Cat(string name):Animal (name){
			cout << "Cats inherited animal..." << endl;
		}
		string sound(){
			return name + ": meow meow";
		}
	};

	int main(){
		Dog d ("Lucky");
		Cat c ("Kitten");

		cout << d.sound() << endl << c.sound() << endl;
		return 0;
	}

欲繼承class Animal，須在classname之後加上: public Animal，除了constructors, destructor, assignment operator memebers(operator=), friends, private members，其餘在class內的成員都會被繼承。
欲繼承Animal的constructor，需在constructor之後加上Animal(name){}，如果沒有加上Animal(name){}來繼承constructor，則會使用default constructor。

C++允許多重繼承。

	#include <iostream>
	#include <cmath>

	using namespace std;

	class Circle{

	public:
		double radius;
		Circle(){}
		Circle (double r){
			this->radius=r;
		}
		double area(){
			return M_PI*radius*radius;
		}
	};

	class Color{
	public:
		string color;
		Color(){}
		Color(string c){
			this->color=c;
		}
	};

	class ColoredCircle: public Circle, public Color{
	public:
		ColoredCircle(double r, string c):Circle (r), Color(c){
		}

		string toString(){
			double d = area();
			string area = to_string(d);
			string s = color + " Circle with area = " + area;
			return s;
		}
	};

	int main(){
		ColoredCircle cc(10.0, "blue");
		cout << cc.toString() << endl;
		return 0;
	}

將要繼承的class用逗號分開即可多重繼承，在constructor處亦然。
to_string(d)用來將數字轉換為字串，方便之後字串相加。
。
。
。
。

只在此山中，雲深不知處

聽首歌

Array & Class

Array

Class