技術標籤：筆記

真∙面向物件

Object Oriented Programming

class class_name
{
	instance varibles
public:
	member_functions
private:
	...
};

class_name obj_name()//generate_function
obj_name.xxx

特性

• 繼承

區別於Java，可以繼承多個類

class C:public A,public B
{
};

• 封裝

• 多型

介面

class Base
{
public:
	virtual int func();
}

class
 
 R: public Base
{
public:
	int func()
	{
		//...
	}
}

與結構體的區別

結構體可以看作一種特殊的類，而且成員預設情況下是公共的（public），類在預設情況下成員是私有的(private)，當然結構體可以有public、private、protected變數，也可以有自己的函式，基本用在儲存資料的輕量級物件。而類是採用面向物件的思想，除了有各種型別的變數外，也可以有成員函式、建構函式、解構函式，可以從別的類繼承（extends），也可以被別的類繼承，可以實現介面（implements），除了封裝各種資料，更可以用於存在複雜的邏輯關係的情況（表現多級別的物件層次）

一個栗子（關於friend）

class fraction
{
public:
    int m = 0;
    int n = 1;
    int getN(){return n;}
    int getM(){return m;}
    fraction(int N,int M):n(N),m(M){}
    friend ostream& operator << (ostream& os,const fraction &a);
private:
};

ostream& operator << (ostream&
 
 os,const fraction &a)
{
    return os << a.m << " / " << a.n << endl;
}

fraction f(1,2);
cout << f;

這裡的過載有點像Java裡的toString()

友元機制

友元函式（friend）

友元函式是可以直接訪問類的私有成員的非成員函式。它是定義在類外的普通函式，它不屬於任何類。

友元類

一個類 A 可以將另一個類 B 宣告為自己的友元，類 B 的所有成員函式就都可以訪問類 A 物件的私有成員。

class A
{
	friend class B;
};
class B
{
};

類成員函式作為友元函式

class A
{
	friend int B::func(A a);
};
class B
{
	int func(A a);
};

能夠提高效率，表達簡單、清晰，但是破環了封裝機制

struct

#define MATRIX_SIZE 1001
using namespace std;
struct Matrix
{
    int r,c;
    int data[MATRIX_SIZE][MATRIX_SIZE];
    Matrix(int C,int R):c(C),r(R)
    {
        memset(data, 0, sizeof(data));
    }
    int* operator [](int pos)
    {
        return data[pos];
    }
    Matrix operator +(Matrix A)
    {
        Matrix C(r,c);
        for(int i = 1;i <= r;++i)
        {
            for(int j = 1;j <= c;++j)
            {
                C[i][j] = data[i][j] + A[i][j];
            }
        }
        return C;
    }
    Matrix operator -(Matrix A)
    {
        Matrix C(r,c);
        for(int i = 1;i <= r;++i)
        {
            for(int j = 1;j <= c;++j)
            {
                C[i][j] = data[i][j] - A[i][j];
            }
        }
        return C;
    }
    Matrix operator *(int b)
    {
        Matrix C(r,c);
        for(int i = 1;i <= r;++i)
        {
            for(int j = 1;j <= c;++j)
            {
                C[i][j] = b*data[i][j];
            }
        }
        return C;
    }
    Matrix operator *(Matrix A)
    {
        Matrix C(r,A.c);
        for(int i = 1;i <= r;++i)
        {
            for(int j = 1;j <= A.c;++j)
            {
                for(int k = 1;k <= c;++k)
                {
                    C[i][j] += data[i][k] + A[k][j];
                }
            }
        }
        return C;
    }
    Matrix T()
    {
        Matrix C(c,r);
        for(int i = 1;i <= r;++i)
        {
            for(int j = 1;j <= c;++j)
            {
                C[j][i] = data[i][j];
            }
        }
        return C;
    }
};

to be continued…