【C++】從設計原理來看string類

typedef char* PCHAR;
PCHAR pa, pb;  // 同時宣告兩個char型別的指標pa和pb
char* pa, pb;  // 宣告一個指標（pa）和一個char變數（pb）
// 下邊的宣告也是建立兩個char型別的指標。但相對沒有typedef的形式直觀，尤其在需要大量指標的地方
char *pa, *pb; 　

char *pa;  // 強調*pa是一個char型別的值，C中多用這種格式。
char* pa;  // 強調char*是一種型別——指向char的指標。C++中多用此種格式。另外在C++中char*是一種複合型別。

1 // 定義
2 struct StudentStruct 
3 {
4     int ID;
5     string name;
6 };
7 // C宣告StudentStruct型別物件
8 struct StudentStruct s1;

1 // 定義
2 typedef struct StudentStruct 
3 {
4     int ID;
5     string name;
6 }Student;
7 // C宣告StudentStruct型別物件s1和s2
8 Student s1, s2;

// C++宣告StudentStruct型別物件s1和s2
StudentStruct s1，s2;

typedef long double REAL;

typedef double REAL; 

typedef float REAL; 

 1 // Definitions of common types
 2 #ifdef _WIN64
 3     typedef unsigned __int64 size_t;
 4     typedef __int64          ptrdiff_t;
 5     typedef __int64          intptr_t;
 6 #else
 7     typedef unsigned int     size_t;
 8     typedef int              ptrdiff_t;
 9     typedef int              intptr_t;
10 #endif

 1 // 理解下邊這種複雜宣告可用「右左法則」：
 2 // 從變數名看起，先往右，再往左，碰到一個圓括號就調轉閱讀的方向；括號內分析完就跳出括號，還是按先右後左的順序，如此迴圈，直到整個宣告分析完。
 3 
 4 // 例1
 5 void* (*(*a)(int))[10];
 6 // 1、找到變數名a，往右看是圓括號，調轉方向往左看到*號，說明a是一個指標；
 7 // 2、跳出內層圓括號，往右看是參數列，說明a是一個函數指標，接著往左看是*號，說明指向的函數返回值是指標；
 8 // 3、再跳出外層圓括號，往右看是[]運運算元，說明函數返回的是一個陣列指標，往左看是void*，說明陣列包含的型別是void*。 
 9 // 簡言之，a是一個指向函數的指標，該函數接受一個整型引數並返回一個指向含有10個void指標陣列的指標。
10 
11 // 例2
12 float(*(*b)(int, int, float))(int);// 1、找到變數名b，往右看是圓括號，調轉方向往左看到*號，說明b是一個指標；
13 // 2、跳出內層圓括號，往右看是參數列，說明b是一個函數指標，接著往左看是*號，說明指向的函數返回值是指標；
14 // 3、再跳出外層圓括號，往右看還是參數列，說明返回的指標是一個函數指標，該函數有一個int型別的引數，返回值型別是float。
15 // 簡言之，b是一個指向函數的指標，該函數接受三個引數(int, int和float)，且返回一個指向函數的指標，該函數接受一個整型引數並返回一個float。
16 
17 // 例3
18 double(*(*(*c)())[10])();
19 // 1、先找到變數名c（這裡c其實是新型別名），往右看是圓括號，調轉方向往左是*，說明c是一個指標；
20 // 2、跳出圓括號，往右看是空參數列，說明c是一個函數指標，接著往左是*號，說明該函數的返回值是一個指標；
21 // 3、跳出第二層圓括號，往右是[]運運算元，說明函數的返回值是一個陣列指標，接著往左是*號，說明陣列中包含的是指標；
22 // 4、跳出第三層圓括號，往右是參數列，說明陣列中包含的是函數指標，這些函數沒有引數，返回值型別是double。
23 // 簡言之，c是一個指向函數的指標，該函數無引數，且返回一個含有10個指向函數指標的陣列的指標，這些函數不接受引數且返回double值。
24 
25 // 例4
26 int(*(*d())[10])();  // 這是一個函數宣告，不是變數定義
27 // 1、找到變數名d，往右是一個無參參數列，說明d是一個函數，接著往左是*號，說明函數返回值是一個指標；
28 // 2、跳出裡層圓括號，往右是[]運運算元，說明d的函數返回值是一個指向陣列的指標，往左是*號，說明陣列中包含的元素是指標；
29 // 3、跳出外層圓括號，往右是一個無參參數列，說明陣列中包含的元素是函數指標，這些函數沒有引數，返回值的型別是int。
30 // 簡言之，d是一個返回指標的函數，該指標指向含有10個函數指標的陣列，這些函數不接受引數且返回整型值。

void* (*(*a)(int))[10];
void* (*(*a2)(int))[10];

// 在之前的定義前邊加typedef，然後將變數名a替換為型別名A
typedef void* (*(*A)(int))[10];

// 定義相同型別的變數a和a2
A a, a2;

typedef char* PSTR;
int mustrcmp(const PSTR, const PSTR); 

typedef static int INT2; 

1 #define add(x, y) (x + y)   //此處要打括號，不然執行2*add(x,y)會變成 2*x + y
2 int main()
3 {
4     std::cout << add(9, 12) << std::endl;  // 輸出21
5     return 0;
6 }

#ifndef DATATYPE_H
#define DATATYPE_H
...
#endif

 1 #ifdef WINDOWS
 2 ...
 3 (#else)
 4 ...
 5 #endif
 6 #ifdef LINUX
 7 ...
 8 (#else)
 9 ...
10 #endif

 1 #include <stdio.h>    
 2 #define trace(x, format) printf(#x " = %" #format "\n", x)    
 3 #define trace2(i) trace(x##i, d)   
 4   
 5 int main(int argc, _TCHAR* argv[])  
 6 {  
 7     int i = 1;  
 8     char *s = "three";    
 9     float x = 2.0;  
10   
11     trace(i, d);                // 相當於 printf("x = %d\n", x)  
12     trace(x, f);                // 相當於 printf("x = %f\n", x)  
13     trace(s, s);                // 相當於 printf("x = %s\n", x)  
14   
15     int x1 = 1, x2 = 2, x3 = 3;    
16     trace2(1);                  // 相當於 trace(x1, d)  
17     trace2(2);                  // 相當於 trace(x2, d)  
18     trace2(3);                  // 相當於 trace(x3, d)  
19   
20     return 0;  
21 }
22 
23 // 輸出：
24 // i = 1
25 // x = 2.000000
26 // s = three
27 // x1 = 1
28 // x2 = 2
29 // x3 =3

1 #define PR(...) printf(__VA_ARGS__)
2 int main()
3 {
4     int wt=1,sp=2;
5     PR("hello\n");   // 輸出：hello
6     PR("weight = %d, shipping = %d",wt,sp);   // 輸出：weight = 1, shipping = 2
7     return 0;
8 }

#include  // 包含一個原始碼檔案
#define   // 定義宏
#undef    // 取消已定義的宏
#if       // 如果給定條件為真，則編譯下面程式碼
#ifdef    // 如果宏已定義，則編譯下面程式碼
#ifndef   // 如果宏沒有定義，則編譯下面程式碼
#elif     // 如果前面#if給定條件不為真，當前條件為真，則編譯下面程式碼
#endif    // 結束一個#if...#else條件編譯塊
#error    // 停止編譯並顯示錯誤資訊

__FILE__      // 在預編譯時會替換成當前的原始檔cpp名
__LINE__      // 在預編譯時會替換成當前的行號
__FUNCTION__  // 在預編譯時會替換成當前的函數名稱
__DATE__      // 進行預處理的日期（「Mmm dd yyyy」形式的字串文字）
__TIME__      // 原始檔編譯時間，格式為「hh：mm：ss」

#define BYTE char  // 將Byte作為char的別名
typedef char byte;

typedef float* float_pointer;

#define FLOAT_POINTER float*
FLOAT_POINTER pa, pb; 

using namespace std;  // 也可在程式碼中直接使用std::

// 使用using（C++11）
using counter = long;

// 使用typedef（C++03）
// typedef long counter;

1 // 使用using（C++11）
2 using func = void(*)(int);
3 
4 // 使用typedef（C++03）
5 // typedef void (*func)(int);
6 
7 // func can be assigned to a function pointer value
8 void actual_function(int arg) { /* ... */ }
9 func fptr = &actual_function;

template<typename T> using ptr = T*;

// the name 'ptr<T>' is now an alias for pointer to T
ptr<int> ptr_int;

template <class T1, class T2>...
template <typename T1, typename T2>...

template<class T> class X
{
   typename T::Y m_y;   // m_y依賴於模板引數T，所以m_y是依賴名稱；m_y同時又巢狀在X類中，所以m_y又是巢狀依賴名稱
};

1 template <class T>
2 class C1 : typename T::InnerType     // Error - typename not allowed.
3 {};
4 template <class T>
5 class C2 : A<typename T::InnerType>  // typename OK.
6 {};

template <typename T>  // or template <class T>
void f(T a, T b) 
{...}

 1 #include <iostream>
 2 
 3 // 常規模板
 4 template <typename T>
 5 void Swap(T &a, T &b);
 6 
 7 struct job
 8 {
 9     char name[40];
10     double salary;
11     int floor;
12 };
13 
14 // 顯示具體化
15 template <> void Swap<job>(job &j1, job &j2);
16 
17 int main()
18 {
19     using namespace std;
20     cout.precision(2);    // 保留兩位小數精度
21     cout.setf(ios::fixed, ios::floatfield);    // fixed設定cout為定點輸出格式；floatfield設定輸出時按浮點格式，小數點後有6為數位
22     
23     int i = 10, j = 20;
24     Swap(i, j);    // 生成Swap的一個範例：void Swap(int &, int&)
25     cout << "i, j = " << i << ", " << j << ".\n";
26 
27     job sxx = { "sxx", 200, 4 };
28     job xt = { "xt", 100, 3 };
29     Swap(sxx, xt);    // void Swap(job &, job &）
30     cout << sxx.name << ": " << sxx.salary << " on floor " << sxx.floor << endl;
31     cout << xt.name << ": " << xt.salary << " on floor " << xt.floor << endl;
32 
33     return 0;
34 }
35 
36 // 通用版本，交換兩個型別的內容，該型別可以是結構體
37 template <typename T>
38 void Swap(T &a, T &b)
39 {
40     T temp;
41     temp = a;
42     a = b;
43     b = temp;
44 }
45 
46 // 顯示具體化，僅僅交換job結構的salary和floor成員，而不交換name成員
47 template <> void Swap<job>(job &j1, job &j2)
48 {
49     double t1;
50     int t2;
51     t1 = j1.salary;
52     j1.salary = j2.salary;
53     j2.salary = t1;
54     t2 = j1.floor;
55     j1.floor = j2.floor;
56     j2.floor = t2;
57 }

 1 template <class T>
 2 void Swap(T &, T &);    // 模板原型
 3 
 4 template <> void Swap<job>(job &, job &);    // 顯示具體化
 5 template void Swap<char>(char &, char &);    // 顯式範例化
 6 
 7 int main(void)
 8 {
 9     short a, b;
10     Swap(a, b);    // 隱式範例化
11     
12     job n, m;
13     Swap(n, m);    // 使用顯示具體化
14     
15     char g, h;
16     Swap(g, h);    // 使用顯式模板範例化
17 }

template <class T1, Class T2>
auto ft(T1 x, T2 y) -> decltype(x + y)
{
    return x + y; 
}

1 // 類別範本定義
2 template <typename T>   // or template <class T>
3 class A 
4 {...}
5 
6 // 範例化
7 A<t> st;  // 用具體型別t替換泛型識別符號(或者稱為型別引數）T

1 // 通用模板
2 template <typename T1, typename T2> class Pair {...};
3 // 部分具體化模板（T1不變，T2具體化為int）
4 template <typename T1> class Pair<T1, int> {...};
5 // 顯示具體化（T1和T2都具體化為int）
6 template <> calss Pair<int, int> {...};

Pair<double, double> p1;  // 使用通用模板進行範例化
Pair<double, int> p2;     // 使用Pair<T1, int>部分具體化模板進行範例化    
Pair<int, int> p3;        // 使用Pair<T1, T2>顯式具體化模板進行範例化

// 通用模板
template <typename T> class Feeb {...};
// 指標部分具體化模板
template <typename T*> class Feeb {...};

Feeb<char> fb1;    // 使用通用模板，T為char型別
Feeb<char *> fb2;  // 使用Feeb T*具體化，T為char型別

 1 #include <iostream>
 2 using std::cout;
 3 using std::endl;
 4 
 5 template <typename T>
 6 class beta
 7 {
 8 private:
 9     template <typename V>  // 巢狀的模板類成員（只能在beta類中存取）
10     class hold
11     {
12     private:
13         V val;
14     public:
15         hold(V v = 0) :val(v) {}
16         void show() const { cout << val << endl; }
17         V value() const { return val; }
18     };
19     // beta類使用hold模板宣告兩個資料成員
20     hold<T> q;    // q是基於T型別（beta模板引數）的hold物件
21     hold<int> n;  // n是基於int的hold物件
22 public:
23     beta(T t, int i) :q(t), n(i) {}
24     template <typename U>  // 模板方法
25     U blab(U u, T t) { return  (n.value() + q.value()) * u / t; }
26     void Show() const { (q.show(); n.show(); }
27 };
28 
29 int main()
30 {
31     beta<double> guy(3.5, 3);
32     cout << "T was set to double\n";
33     guy.Show();
34     cout << "V was set to T, which id double, then V was set to int\n";
35     cout << guy.blab(10, 2.3) << endl;
36     cout << "U was set to int\n";
37     cout << guy.blab(10.0, 2.3) << endl;
38     cout << "U was set to double\n";
39     cout << "Done\n";
40     return 0;
41 }

template <template <typename T> class Type>
class B

 1 #include <iostream>
 2 #include "stacktp.h"
 3 template <template <typename T> class Thing>
 4 class Crab
 5 {
 6 private:
 7     Thing<int> s1;
 8     Thing<double> s2;
 9 public:
10     Crab() {};
11     // 假設pop()和push()是Thing類的成員函數
12     bool push(int a, double x) { return s1.push(a) && s2.push(x); }
13     bool pop(int& a, double& x) { return s1.pop(a) && s2.pop(x); }
14 };
15 
16 int main()
17 {
18     using std::cout;
19     using std::cin;
20     using std::endl;
21 
22     Crab<Stack> nebula;
23     int ni;
24     double nb;
25     while (cin >> ni >> nb && ni > 0 && nb > 0)
26     {
27         if (!nebula.push(ni, nb))
28             break;
29     }
30     while (nebula.pop(ni, nb))
31         cout << ni << ", " << nb << endl;
32     cout << "Done.\n";
33     return 0;
34 }

vector<int> vec{ 0,1,2,3,4 };
for (auto it = begin(vec); it != end(vec); it++)
{
    // 使用解除參照運運算元存取元素
    cout << *it << " ";
}

for (auto num : vec)
{
    // 不使用解除參照運運算元
    cout << num << " ";
}

#define SQUARE(X) X*X
a = SQUARE(2 + 3)    // 相當於 a = 2 + 3 * 2 + 3

  1 class Time
  2 {
  3 private:
  4     int hours;
  5     int minutes;
  6 public:
  7     Time();
  8     Time(int h, int m = 0);
  9     void AddMin(int m);
 10     void AddHr(int h);
 11     void Reset(int h = 0, int m = 0);
 12     Time Sum(const Time& t) const;          // Sum函數
 13     Time operator+ (const Time & t) const;  // 使用過載的加法運運算元
 14     void Show() const;
 15 };
 16 
 17 Time::Time()
 18 {
 19     hours = minutes = 0;
 20 }
 21 
 22 Time::Time(int h, int m)
 23 {
 24     hours = h;
 25     minutes = m;
 26 }
 27 
 28 void Time::AddMin(int m)
 29 {
 30     minutes += m;
 31     hours += minutes / 60;
 32     minutes %= 60;
 33 }
 34 
 35 void Time::AddHr(int h)
 36 {
 37     hours += h;
 38 }
 39 
 40 void Time::Reset(int h, int m)
 41 {
 42     hours = h;
 43     minutes = m;
 44 }
 45 
 46 // 注意：不要返回指向區域性變數或臨時物件的參照。函數執行完畢後，區域性變數和臨時物件將消失，參照將指向不存在的資料。
 47 Time Time::Sum(const Time& t) const
 48 {
 49     Time sum;
 50     sum.minutes = minutes + t.minutes;
 51     sum.hours = hours + t.hours + t.minutes / 60;
 52     sum.minutes %= 60;
 53     return sum;
 54 }
 55 
 56 Time Time::operator+(const Time& t) const
 57 {
 58     Time sum;
 59     sum.minutes = minutes + t.minutes;
 60     sum.hours = hours + t.hours + t.minutes / 60;
 61     sum.minutes %= 60;
 62     return sum;
 63 }
 64 
 65 void Time::Show() const
 66 {
 67     std::cout << hours << " hours, " << minutes << " minutes";
 68 }
 69 
 70 int main()
 71 {
 72     using std::cout;
 73     using std::endl;
 74     Time planning;
 75     Time coding(2, 40);
 76     Time fixing(5, 55);
 77     Time total;
 78 
 79     cout << "planning time = ";
 80     planning.Show();
 81     cout << endl;
 82 
 83     cout << "coding time = ";
 84     coding.Show();
 85     cout << endl;
 86 
 87     cout << "fixing time = ";
 88     fixing.Show();
 89     cout << endl;
 90 
 91     // Sum函數
 92     total = coding.Sum(fixing);
 93     cout << "coding.sum(fixing) = ";
 94     total.Show();
 95     cout << endl;
 96 
 97     // 使用過載運運算元
 98     total = coding + fixing;  // 與下一句程式碼等效
 99     total = coding.operator+(fixing); 
100     cout << "coding + fixing = ";
101     total.Show();
102     cout << endl;
103 
104     return 0;
105 }

total = coding + fixing; 
total = coding.operator+(fixing); 

1 void (Test::*pfunc)() = &Test::func;
2 Test t1;
3 Test* t2 = new Test();
4 
5 t1.func();        // 正常呼叫類成員方法
6 (t1.*pfunc)();    // 通過函數指標呼叫類成員方法
7 
8 t2->func();       // 正常呼叫類成員方法
9 (t2->*pfunc)();   // 通過函數指標呼叫類成員方法

 1 #include <iostream>
 2 
 3 using namespace std;
 4 class Point
 5 {
 6     friend void ChangePrivate(Point&);
 7 public:
 8     Point(void) : m_i(0) {}  // 建構函式成員初始化列表
 9     void PrintPrivate(void) { cout << m_i << endl; }
10 
11 private:
12     int m_i;
13 };
14 
15 void ChangePrivate(Point& i) { i.m_i++; }
16 
17 int main()
18 {
19     Point sPoint;
20     sPoint.PrintPrivate();
21     ChangePrivate(sPoint);
22     sPoint.PrintPrivate();
23     // Output: 0
24     //         1
25 }

 1 Class Tv;  // 前向宣告，避免迴圈依賴
 2 
 3 class Remote
 4 {
 5 public:
 6     void set_chan(Tv & t, int c) {t.channel = c;}  // 行內函式
 7     ...
 8 };
 9 
10 Class Tv
11 {
12 private:
13    int channel;
14 public:
15     friend void Remote::set_chan(Tv & t, int c);
16     ...
17 };　　

 1 Class Tv
 2 {
 3     friend class Remote;
 4 public:
 5     void buzz(Remote & r);
 6     ...
 7 };
 8 
 9 class Remote
10 {
11     friend class Tv;
12 public:
13     void Bool volup(Tv & t) { t.volup(); }
14     ...
15 };
16 
17 inline void Tv::buzz(Remote & r)
18 {
19     ...
20 }

 1 class B;  // 前向宣告（forward declaration）
 2 class A
 3 {
 4     friend void sync(B& a, const A& p);  // sync a to p
 5     friend void sync(A& P, const B& a);  // sync p to a
 6 };
 7 class B
 8 {
 9     friend void sync(B& a, const A& p);  // sync a to p
10     friend void sync(A& P, const B& a);  // sync p to a
11 };
12 
13 // 友元函數定義
14 inline void sync(B& a, const A& p)
15 {
16     ...
17 }
18 inline void sync(A& P, const B& a)
19 {
20     ...
21 }

 1 #include <iostream>
 2 
 3 int main()
 4 {
 5     using namespace std;
 6     char ch = 'M';
 7     int i = ch;
 8     cout << "The ASCII code for " << ch << " is " << i << endl;
 9 
10     ch += 1;
11     i = ch;
12     cout << "The ASCII code for " << ch << " is " << i << endl;
13 
14     cout << "Displaying char ch using cout.put(ch): ";
15     cout.put(ch);
16 
17     cout.put('!');
18     return 0;
19 }

cout << endl;
cout << '\n';
cout << "\n";   // 相當於'\n'在字串中，不需要加單引號

wchar_t blb = L'P'
wcout << L"tall" << endl;

 1 #define _STD ::std::
 2 
 3 template <class _Elem,                   // _Elem是儲存在字串中的型別
 4     class _Traits = char_traits<_Elem>,  // _Traits引數是一個類，定義了型別要被表示為字串時，所必須具備的特徵
 5     class _Alloc = allocator<_Elem>>     // _Alloc是用於處理字串記憶體分配的類
 6     class basic_string
 7 {                                        // null-terminated transparent array of elements
 8 private:
 9     friend _Tidy_deallocate_guard<basic_string>;
10     friend basic_stringbuf<_Elem, _Traits, _Alloc>;
11 
12     using _Alty = _Rebind_alloc_t<_Alloc, _Elem>;
13     using _Alty_traits = allocator_traits<_Alty>;
14 
15     ... 
16 
17 public:
18     // using源於C++11，等價於C++98的typedef，比如下邊第一行程式碼相當於：typedef _Traits traits_type;
19     using traits_type = _Traits;                                     // _Traits是對應於特定型別（如char_traits<char>）的模板引數
20     using allocator_type = _Alloc;
21 
22     using value_type = _Elem;
23     using size_type = typename _Alty_traits::size_type;              // 根據儲存的型別返回字串的長度（無符號型別）
24     using difference_type = typename _Alty_traits::difference_type;  // 用於度量字串中兩個元素之間的距離（size_type有符號版本）
25     using pointer = typename _Alty_traits::pointer;                  // 對於char具體化，pointer型別為char *，與基本指標有著相同的特徵
26     using const_pointer = typename _Alty_traits::const_pointer;
27     using reference = value_type&;                                   // 對於char具體化，reference型別為char &，與基本參照有著相同的特徵
28     using const_reference = const value_type&;
29 
30     using iterator = _String_iterator<_Scary_val>;                   // 迭代器型別
31     using const_iterator = _String_const_iterator<_Scary_val>;
32 
33     using reverse_iterator = _STD reverse_iterator<iterator>;
34     using const_reverse_iterator = _STD reverse_iterator<const_iterator>;
35 
36     ...
37 
38     // 靜態常數npos，size_type是無符號的，因此將-1賦給npos相當於將最大的無符號值賦給它，這個值比可能的最大陣列索引大1
39     static constexpr auto npos{ static_cast<size_type>(-1) };  
40 };

using string = basic_string<char, char_traits<char>, allocator<char>>;
using wstring = basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t>>;
using u16string = basic_string<char16_t, char_traits<char16_t>, allocator<char16_t>>;
using u32string = basic_string<char32_t, char_traits<char32_t>, allocator<char32_t>>;

 1 #include <string>
 2 #include <iostream>
 3 
 4 int main()
 5 {
 6     using namespace std;
 7     
 8     string one("SXX Winner!");    // ctor 1，將string物件one初始化為常規的C-風格字串
 9     cout << one << endl;
10 
11     string two(20, '$');    // ctor 2，將string物件two初始化為由20個$字元組成的字串
12     cout << two << endl;
13 
14     string three(one);    // ctor 3，複製建構函式將string物件three初始化為one
15     cout << three << endl;
16 
17     one += " Oops!";
18     cout << one << endl;
19 
20     two = "Sorry! That was ";
21     three[0] = 'Y';
22     string four;    // ctor 4，預設建構函式建立一個以後可以對其進行賦值的空字串
23     four = two + three;
24     cout << four << endl;
25     
26     char alls[] = "All's well that ends well";
27     string five(alls, 20);    // ctor 5, 將five初始化為alls的前20個字元
28     cout << five << "!\n";
29 
30     string six(alls + 6, alls + 10);
31     cout << six << ", ";    // ctor 6，將string物件six初始化為區間[6,10)內的字元
32     
33     string seven(&five[6], &five[10]);    // ctor 6, five[6]是一個char值，&five[6]是地址
34     cout << seven << "...\n";
35 
36     string eight(four, 7, 16);    // ctor 7, 將物件four的部分內容複製到構造的物件中
37     cout << eight << " in motion!" << endl;
38 
39     return 0;
40 }

1 // 能夠使用陣列表示法來存取字串的元素，可用於檢索或更改值
2 reference operator[](size_type pos);
3 // 可用於const物件，但只能用來檢索值
4 const_reference operator[](size_type pos) const;
5 // 功能同第一句程式碼，索引通過函數引數提供
6 reference at(size_type n);
7 // 功能同第二句程式碼，索引通過函數引數提供
8 const_reference at(size_type n) const;

string snake("cobra");
int where = snake.find_first_of("hark")  // 返回r在「cobra」中的位置（即索引3）

string snake("cobra");
int where = snake.find_last_of("hark")  // 返回a在「cobra」中的位置（即索引4）

string snake("cobra");
int where = snake.find_first_not_of("hark")  // 返回c在「cobra」中的位置（即索引0）,因為「hark」中沒有c

string snake("cobra");
int where = snake.find_first_not_of("hark")  // 返回b在「cobra」中的位置（即索引2）,因為「hark」中沒有b

basic_string& assign(const basic_string& str)

// copy()原型，s指向目標陣列，n是要複製的字串，pos指從string物件的什麼位置開始複製
size_type copy(charT* s, size_type n, size_type pos = 0) const;

// swap()原型
void swap(basic_string& str);

char info[100];
cin >> info;             // read a word                   
cin.getline(info, 100);  // read a line, discard \n     
cin.get(info, 100);      // read a line, leave \n in queue

string stuff;
cin >> stuff;          // read a word                   
getline(cin, stuff);   // read a line, discard \n 

cin.getline(info, 100, ':');  // read up to :, discard :
getline(cin, stuff, ':');     // read up to :, discard :