C++筆記

----------------------------------------------

//ok

int ival( 1024 );

int ival(int());

 

//每種內建資料類型都支援一種特殊的建構函式文法可將對象初始化為0

int ival=int();

-------------------------------------------------

試圖將一個非const 對象的指標指向一個常量對象的動作都將引起編譯錯誤，

const 對象的地址只能賦值給指向const 對象的指標， 但是指向const 對象的指標可以被賦以一個非const 對象的地址

const double minWage = 9.60;
//  error！
double *ptr = &minWage;

--------------------------------------------------------

常量指標：指向常量的指標，指標所指向的地址的內容是不可修改的。

如：const int *p=&a;(p指向const int)

指標常量:指標的常量，它是不可改變地址的指標，但是可以對它所指向的內容進行修改.

如：int * const p=&a;(const p指向int)

-------------------------------------------------------------

參考型別：引用reference 有時候又稱為別名alias 它可以用作對象的另一個名字。

int ival = 1024;
int &refVal = ival;

------------------------------------------------------

枚舉類型用法

enum open_modes{ input = 2, output, append };
open_modes om=output;
cout<<om<<endl;

// point2d == 2, point2w == 3, point3d == 3, point3w == 4
enum Points { point2d = 2, point2w, point3d = 3, point3w };

void mumble() {
Points pt3d = point3d; // ok: pt3d == 3
// 錯誤pt2w 被初始化為一個int 整數
Points pt2w = 3;
// 錯誤polygon 不是Points 的枚舉成員
pt2w = polygon;
// ok: pt2w 和pt3d 都是Points 枚舉類型
pt2w = pt3d;
}
但是在必要時枚舉類型會自動被提升成算術類型例如
const int array_size = 1024;
// ok: pt2w 被提升成int 類型
int chunk_size = array_size * pt2w;

----------------------------------------------------

迭代器用法

vector< string > text;

for ( vector<string>::iterator it = text.begin();
it != text.end(); ++it )
cout << *it << ' ';

//ok

int ia[ 7 ] = { 0, 1, 1, 2, 3, 5, 8 };
vector< int > ivec1(ia,ia+5) ;

------------------------------------------------------

下面是一個幾乎所有人剛開始時都會答錯的問題錯誤在於將typedef 當作宏擴充已
知下面的typedef
typedef char *cstring;
在以下聲明中cstr 的類型是什麼
extern const cstring cstr;
第一個回答差不多都是
const char *cstr
即指向const 字元的指標但是這是不正確的const 修飾cstr 的類型cstr 是一個指
針因此這個定義聲明了cstr 是一個指向字元的const 指標見3.5 節關於const 指標類型
的討論
char *const cstr;

------------------------------------------------------------

volatile 修飾符的主要目的是提示編譯器該對象的值可能在編譯器未監測到的情況下被
改變因此編譯器不能武斷地對引用這些對象的代碼作最佳化處理

------------------------------------------------------------

pair 類也是標準庫的一部分它使得我們可以在單個對象內部把相同類型或不同類型的
兩個值關聯起來為了使用pair 類我們必須包含下面的標頭檔
#include <utility>
例如
pair< string, string > author( "James", "Joyce" );
建立了一個pair 對象author 它包含兩個字串分別被初始化為James 和Joyce
我們可以用成員訪問符號member access notation 訪問pair 中的單個元素它們的名
字為first 和second 例如
string firstBook;
if ( author.first == "James" &&
author.second == "Joyce" )
firstBook = "Stephen Hero";
如果我們希望定義大量相同pair 類型的對象那麼最方便的做法就是用typedef 如下所
示
typedef pair< string, string > Authors;
Authors proust( "marcel", "proust" );
Authors joyce( "james", "joyce" );
Authors musil( "robert", "musil" );

--------------------------------------------------------------

向前聲明

可以聲明一個類而不定義它
   class Screen;//declaration of the Screen class
   這個聲明,有時候被稱為前向聲明(forward declaration),在程式中引入了類類型的Screen.在聲明之後,定義之前,類Screen是一個不完全類型(incompete type),即已知Screen是一個類型,但不知道包含哪些成員.
   不完全類型只能以有限方式使用,不能定義該類型的對象,不完全類型只能用於定義指向該類型的指標及引用,或者用於聲明(而不是定義)使用該類型作為形參類型或傳回型別的函數.

// 前向聲明(forward declaration)
class EntrySlot;
extern EntrySlot* look_up( string );
typedef pair< string, EntrySlot* > SymbolEntry;
SymbolEntry current_entry( "author", look_up( "author" ));

// ...
if ( EntrySlot *it = look_up( "editor" ))
{
current_entry.first = "editor";
current_entry.second = it;
}

--------------------------------------------------------------

操作符重載

被重載的操作符採用下面的一般形式
return_type operator op ( parameter_list );
這裡的operator 是關鍵字op 是一個預定義的操作符如+ = == []

char& operator[]( int );
聲明了一個下標操作符的重載執行個體它帶有一個int 型的參數返回指向char 的引用

例如
// 放在程式文字檔中: String.C
// 包含String 類的定義
#include "String.h"
// 包含strcmp()函數的聲明
// cstring 是標準C 庫的標頭檔
#include <cstring>
bool // 傳回型別
String:: // 說明這是String 類的一個成員
operator== // 函數的名字: 等於操作符
(const String &rhs) // 參數列表
{
if ( _size != rhs._size )
return false;
return strcmp( _string, rhs._string ) ? false : true;
}

inline String&
String::operator=( const String &rhs )
{
if ( this != &rhs )

 

{
delete [] _string;
_size = rhs._size;
if ( ! rhs._string )
_string = 0;
else {
_string = new char[ _size + 1 ];
strcpy( _string, rhs._string );
}
}
return *this;
}

==============

bitset< 32 > bitvec;

定義32位bitset

----------------------------------

顯式轉換

顯式轉換也被稱為強制類型轉換cast 包括下列命名的強制類型轉換操作符
static_cast dynamic_cast const_cast 和reinterpret_cast 雖然有時候確實需要強制類型轉
換但是它們也是程式錯誤的源泉通過使用它們程式員關閉了C++語言的類型檢查設
施在瞭解怎樣把一個值從一種類型強制轉換成另一種類型之前我們先來看一下何時需
要這麼做
任何非const 資料類型的指標都可以被賦值給void*型的指標,void*型指標被用於對象的確切類型未知或者在特定環境下對象的類型會發生變化的情況下有時void*型的指標被稱為泛型generic 指標因為它可以指向任意資料類型的指標

int ival;
int *pi = 0;
char *pc = 0;
void *pv;
pv = pi; // ok: 隱式轉換
pv = pc; // ok: 隱式轉換
const int *pci = &ival;
pv = pci; // 錯誤: pv 不是一個const void*.
const void *pcv = pci; // ok

把void*型的指標賦值給任意顯式類型時C++要求顯式強制轉換

----------------------------------------------------------------------------------------

函數指標

#include <iostream>
int min( int*, int );
int (*pf)( int*, int ) = min;
const int iaSize = 5;
int ia[ iaSize ] = { 7, 4, 9, 2, 5 };
int main() {
cout << "Direct call: min: "

<< min( ia, iaSize ) << endl;
cout << "Indirect call: min: "
<< pf( ia, iaSize ) << endl;
return 0;
}
int min( int* ia, int sz ) {
int minVal = ia[ 0 ];
for ( int ix = 1; ix < sz; ++ix )
if ( minVal > ia[ ix ] )
minVal = ia[ ix ];
return minVal;
}
調用
pf( ia, iaSize );
也可以用顯式的指標符號寫出
(*pf)( ia, iaSize );

 

我們可以聲明一個函數指標的數組例如
int (*testCases[10])();
將testCases 聲明為一個擁有10 個元素的數組，每個元素都是一個指向函數的函數指標
該函數沒有參數傳回型別為int
像數組testCases 這樣的聲明非常難讀因為很難分析出函數類型與聲明的哪部分相關
在這種情況下使用typedef 名字可以使聲明更為易讀例如
// typedefs 使聲明更易讀
typedef int (*PFV)(); // 定義函數類型指標的typedef
PFV testCases[10];
testCases 的這個聲明與前面的等價

[]優先順序大於*,*是自右向左結合

指標數組，顧名思義，就是說的首先是一個數組吧，然後數組的元素是指標而已。

說明形式為：type *pointer_array[constant1][constant2]...[constantn];

數組指標：指向一個數組的指標。說明形式為：type (*pointer_array)[constant1][constant2]...[constantn];int (*ap)[2]; 這樣就說明了一個指向包含有2個元素的整形數組的數組指標

-------------------------------------------------------

函數模板

template <class Type>
Type min( Type a, Type b ) {
return a < b ? a : b;
}

 

template <typename Type, int size>
Type min( Type (&r_array)[size] )
{
Type min_val = r_array[0];
for ( int i = 1; i < size; ++i )
if ( r_array[i] < min_val )
min_val = r_array[i];
return min_val;
}

int ia[] = { 10, 7, 14, 3, 25 };
int i = min( ia );

----------------------------------------------------

 virtual void finalize_state() = 0;//純虛函數，必須在子類中實現

virtual void finalize_state();//虛函數

---------------------------------------------

string str() const;

函式宣告後加const表示該函數不能在函數實現中更改成員變數的值