C++基礎和類、對象

1、常量：
const int a=7;  //C++
#define b  8  //C
2、轉義字符：
轉義字符 意義 ASCII碼值(十進制) 
\a 響鈴(BEL) 007 
\b 退格(BS) 008 
\f 換頁(FF) 012 
\n 換行(LF) 010 
\r 回車(CR) 013 
\t 水平製表(HT) 009 
\v 垂直製表(VT) 011 
\\ 反斜槓 092 
\? 問號字符 063 
\' 單引號字符 039 
\" 雙引號字符 034 
\0 空字符(NULL) 000 
\ddd 任意字符 三位八進制 
\xhh 任意字符 二位十六進制 
3、枚舉類型：
enum EN{A=10,B,C,D,E,F};  //枚舉類型到成員是int類型到，而且總是以1遞增
//EN en=(EN)20;    //第一個元素默認是0，後面依次類推，允許強制類型轉換（當超出範圍時）
EN en=F;
cout<<en<<endl;
4、共用體：
union UN   //共用體類型聲明
{
int a;      //四個字節
short b;    //兩個字節
}un;      //共用體變量定義（像struct一樣也有三種格式吧）
un.a=0x12345678;
cout<<hex<<un.a<<endl;  //hex的作用到最後，結果12345678
cout<<un.b<<endl;       //結果5678
5、new與delete的簡單應用：
//對於一般變量類型，delete[] p與delete p效果一樣，而類的數組則必須用前者
int *p1,*p2;
p1=new int(60);    //爲p1分配60字節到空間
p2=new int[10];    //爲p2分配數組內存，共十個元素（每個元素4字節）
*p1=100;
for(int i=0;i<10;i++)
p2[i]=i;
for(int j=0;j<10;j++)
cout<<p2[j]<<" ";
cout<<endl;
//delete p1;      //這樣也可以
delete[] p1;
delete[] p2;      //最好這樣設置
//delete[12] p2;  //這裏不會出錯


char *p;
//p=new char(60);    //爲p分配60字節到空間,單他只代表一個變量，不能進行字符串到賦值，否則在delete時總要出錯
p=new char[10];  //這裏分配到空間必須足夠大，否則會運行錯誤
strcpy(p,"憶十");
cout<<p<<endl;
delete[] p;  //這裏總是容易出錯!!!!!
6、斷言：
#include <assert.h>   //必須爲assert.h 
#define NDEBUG   //定義此語句可以讓所有的斷言語句失效


int x;
cout<<"x:";
cin>>x;
assert(x<10);   //當x<10時可以通過,否則會出現斷言錯誤
cout<<"x="<<x<<endl;
7、內聯函數：
在類的定義文件中實現的函數默認是內聯函數，但在外部可以添加inline關鍵字！
8、對象內存分配：
C++中每個數據成員分配內存空間，類中的成員函數只生成一個副本！
9、複製構造函數：
類名：：複製構造函數（類名 &引用）
或者
類名：：複製構造函數（const 類名 &引用）
TPoint(const TPoint &obj);
10、對象的深複製與淺複製： 見專題文檔
11、靜態數據成員：
必須初始化
int MyClass::i=0;
12、靜態成員函數：
只能訪問靜態成員、靜態成員函數和類以外的函數和數據，不能訪問類中的非靜態數據成員（因爲非靜態數據成員只有對象創建後纔有意義！）
13、類成員指針：
類數據成員指針：
類型 類名::*指針名
Int MyClass::*p=&MyClass::m;   
MyClass a;
a.*p=10;
p=&MyClass::n;
a.*p=20;
a.disp();
類成員函數指針：
類型（類名::*指針名）(參數表)
……
{
……
void setm(int i){m=i;}
void setn(int i){n=i;}
……
};
Void （MyClass::*pfun）(int);   //類成員函數指針
MyClass a;
pfun=MyClass::setm;
(a.*pfun)(10);
pfun=MyClass::setn;
(a.*pfun)(20);
a.disp();
14、常對象：(極少用到)
類名 const 對象名;   OR    const 類名 對象名;
class MyClass
{
private:
int n;
public:
MyClass(int i) {n=i;}
void setvalue(int i) {n=i;}
void disp()
{
cout<<"n="<<n<<endl;
}
~MyClass()  //可以在析構函數中設置，但一般也很少用到“常對象”
{
cout<<"n="<<n<<endl;
}
};
void main()
{
const MyClass a(10);   //定義常對象
//以下兩句代碼都不正確，常對象不能顯示到顯示任何成員函數及變量
//a.setvalue(6);  
//a.disp();
}
15、常對象成員：(極少用到)
類型 函數名（參數表） const;
注意：
const是函數類型的一個組成部分，因此在實現部分也要帶const關鍵字；
成員函數不更新對象的數據成員，也不能調用該類的沒有用const修飾的成員函數，如果一個對象聲明爲常對象，那麼它只能夠調用它的常成員函數，而不能調用其他的成員函數；
 Const關鍵字可以參與區分重載函數；


class MyClass
{
private:
int n;
public:
MyClass(int i) {n=i;}
void disp()
{
cout<<"n="<<n<<endl;
}
void disp() const  //常成員函數，也算一種重載
{
cout<<"n="<<n<<endl;
}
};
void main()
{
MyClass a(10);
const MyClass b(20);
a.disp();
b.disp();  //此句代碼是正確的
}
16、常數據成員：
當類中定義類多個常數據成員時，構造函數只能通過初始化列表對該數據成員進行初始化，格式如下：
構造函數（參數表）:常數據成員1（參數1）,常數據成員2（參數2），…
例如：
…….
MyClass3(int i,int j):n(i),m(j){};
17、has-a關係：（注意前向引用的聲明）
先調用對象成員的構造函數，在調用自身的構造函數；析構函數調用順序相反；
class Student
{
Teacher t;  //此處的Teacher也是類類型
……
}
18、this指針：一個指向正在被某個成員函數操作的對象的指針；
19、友元：（實際友元函數和友元類都是通過參數來對類進行操作的，因爲參數和返回值經常都會爲類類型！！見下面的例子！）
友元函數：挑戰了封裝性，不是類的成員函數，但可以訪問類中的所有成員！
friend 函數類型 友元函數名（參數表）；
例：
class MyClass
{
private:
int n;
public:
MyClass() {n=0;}
MyClass(int i) {n=i;}
void disp()
{
cout<<"n="<<n<<endl;
}
friend MyClass square(MyClass);  //友元函數聲明
/*
friend void print()  //這段代碼是錯誤的，是不能訪問n的！！
{
n=30;
}
*/
};
MyClass square(MyClass a)
{
int tmp=a.n*a.n;
return MyClass(tmp);  //這種返回類對象的方法很好！
//或者
/*
MyClass mc;
mc.n=a.n*a.n;
return mc;
*/
}
void main()
{
MyClass a(10),b;
b=square(a);
b.disp();  //此句代碼是正確的
}
友元類：如果B類是A類的友元類，那麼B類的成員函數都是A類的友元函數，都可以訪問A類的成員函數和數據成員！
示例：
class A
{
private:
int n;
public:
A(){n=10;}
friend class B;  //聲明友元類B
};
class B
{
public:
void disp(A tmp)  //依然是以參數的形式來訪問
{
cout<<"n="<<tmp.n<<endl;
}
};
void main()
{
A a;
B b;
b.disp(a);
}