c++：-3

PamShao發表於2022-05-05

C++

上一節學習了C++的函式：c++：-2，本節學習C++的陣列、指標和字串

陣列

定義和初始化

定義

例如：int a[10];
表示a為整型陣列，有10個元素：a[0]...a[9]

例如: int a[5][3];
表示a為整型二維陣列，其中第一維有5個下標（0_{4），第二維有3個下標（0}2），陣列的元素個數為15，可以用於存放5行3列的整型資料表格。

使用

必須先宣告，後使用。
只能逐個引用陣列元素，而不能一次引用整個陣列

例如：a[0]=a[5]+a[7]-a[2*3]
例如：b[1][2]=a[2][3]/2

儲存

（1）一維陣列的儲存
陣列元素在記憶體中順次存放，它們的地址是連續的。元素間實體地址上的相鄰，對應著邏輯次序上的相鄰。

（2）二維陣列的儲存
按行存放
例如： float a[3][4];
可以理解為：

其中陣列a的儲存順序為：

\[a00,a01,a02,a03,a10,a11,a12,a13,a20,a21,a22,a23 \]

初始化

（1）一維陣列的初始化

在定義陣列時給出陣列元素的初始值。
列出全部元素的初始值
例如：static int a[10]={0,1,2,3,4,5,6,7,8,9};
可以只給一部分元素賦初值
例如：static int a[10]={0,1,2,3,4};
在對全部陣列元素賦初值時，可以不指定陣列長度
例如：static int a[]={0,1,2,3,4,5,6,7,8,9}

(2)二維陣列的初始化

將所有初值寫在一個{}內，按順序初始化
例如：static int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12
分行列出二維陣列元素的初值
例如：static int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
可以只對部分元素初始化
例如：static int a[3][4]={{1},{0,6},{0,0,11}};
列出全部初始值時，第1維下標個數可以省略
例如：static int a[][4]={1,2,3,4,5,6,7,8,9,10,11,12};
或：static int a[][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}};
注意：
如果不作任何初始化，內部auto型陣列中會存在垃圾資料，static陣列中的資料預設初始化為0；
如果只對部分元素初始化，剩下的未顯式初始化的元素，將自動被初始化為零；

傳參

陣列元素作實參，與單個變數一樣。
陣列名作引數，形、實引數都應是陣列名（實質上是地址），型別要一樣，傳送的是陣列首地址。
對形引數組的改變會直接影響到實引數組。

物件陣列

定義和訪問

（1）定義物件陣列
類名陣列名[元素個數]；

（2）訪問物件陣列元素
通過下標訪問：陣列名[下標].成員名

初始化

陣列中每一個元素物件被建立時，系統都會呼叫類建構函式初始化該物件。
通過初始化列表賦值。
例：Point a[2]={Point(1,2),Point(3,4)};
如果沒有為陣列元素指定顯式初始值，陣列元素便使用預設值初始化（呼叫預設建構函式）。
元素所屬的類不宣告建構函式，則採用預設建構函式。
各元素物件的初值要求為相同的值時，可以宣告具有預設形參值的建構函式。
各元素物件的初值要求為不同的值時，需要宣告帶形參的建構函式。
當陣列中每一個物件被刪除時，系統都要呼叫一次解構函式。

基於範圍的for迴圈

原for迴圈

#include "iostream"

using namespace std;
int main() {
    int array[3] = {1, 2, 3};
    int *p;
    for (p = array; p < array + sizeof(array) / sizeof(int); ++p) {
        *p += 2;
        std::cout << *p << std::endl;
    }
}

新for迴圈

#include "iostream"

using namespace std;
int main() {
    int array[3] = {1, 2, 3};
    for(int & e : array)
    {
        e += 2;
        std::cout<<e<<std::endl;
    }
    return 0;
}

指標

（1）記憶體空間的訪問方式

通過變數名訪問
通過地址訪問

（2）指標的概念

指標：記憶體地址，用於間接訪問記憶體單元
指標變數：用於存放地址的變數

定義

（1）例：
static int i;
static int* ptr = &i;

（2）例：
*ptr = 3;

（3）與地址相關的運算——“*”和“&”

指標運算子：*
地址運算子：&

初始化

（1）語法形式：儲存型別資料型別 *指標名＝初始地址；
例：int *pa = &a;
（2）注意事項

用變數地址作為初值時，該變數必須在指標初始化之前已宣告過，且變數型別應與指標型別一致。
可以用一個已有合法值的指標去初始化另一個指標變數。
不要用一個內部非靜態變數去初始化 static 指標。

賦值

（1）語法形式：指標名=地址
注意：“地址”中存放的資料型別與指標型別必須相符
（2）向指標變數賦的值必須是地址常量或變數，不能是普通整數。例如：

通過地址運算“&”求得已定義的變數和物件的起始地址
動態記憶體分配成功時返回的地址

（3）例外：整數0可以賦給指標，表示空指標。
（4）允許定義或宣告指向 void 型別的指標。該指標可以被賦予任何型別物件的地址。
例： void *general;

指標空值nullptr

（1）以往用0或者NULL去表達空指標的問題：
C/C++的NULL巨集是個被有很多潛在BUG的巨集。因為有的庫把其定義成整數0，有的定義成 (void*)0。在C的時代還好。但是在C++的時代，這就會引發很多問題。
（2）C++11使用nullptr關鍵字，是表達更準確，型別安全的空指標

指向常量的指標

不能通過指向常量的指標改變所指物件的值，但指標本身可以改變，可以指向另外的物件。

例：

int a;
const int *p1 = &a; //p1是指向常量的指標
int b;
p1 = &b; //正確，p1本身的值可以改變
*p1 = 1; //編譯時出錯，不能通過p1改變所指的物件(常量)

指標型別的常量

若宣告指標常量，則指標本身的值不能被改變。

例：

int a;
int * const p2 = &a;
p2 = &b; //錯誤，p2是指標常量，不能改變

運算

算術運算

指標p加上或減去n
其意義是指標當前指向位置的前方或後方第n個資料的起始位置。
指標的++、--運算
意義是指向下一個或前一個完整資料的起始。
運算的結果值取決於指標指向的資料型別，總是指向一個完整資料的起始位置。
當指標指向連續儲存的同型別資料時，指標與整數的加減運和自增自減算才有意義。
（1）指標與整數相加的意義

關係運算

指向相同型別資料的指標之間可以進行各種關係運算。
指向不同資料型別的指標，以及指標與一般整數變數之間的關係運算是無意義的。
指標可以和零之間進行等於或不等於的關係運算。
例如：p==0或p!=0

指標與陣列

用指標訪問陣列

陣列是一組連續儲存的同型別資料，可以通過指標的算術運算，使指標依次指向陣列的各個元素，進而可以遍歷陣列。

（1）定義與賦值：
例：int a[10], pa;
pa=&a[0]; 或 pa=a;
經過上述定義及賦值後：
pa就是a[0]，(pa+1)就是a[1]，... ，(pa+i)就是a[i]。a[i], *(pa+i), *(a+i), pa[i]都是等效的。
（2）注意：
不能寫 a++，因為a是陣列首地址、是常量。
（3）舉例：
設有一個int型陣列a，有10個元素。用三種方法輸出各元素：
方法1：使用陣列名和下標

#include "iostream"
using namespace std;
int main() {
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    for (int i = 0; i < 10; i++)
        cout << a[i] << "  ";
    cout << endl;
    return 0;
}

方法2：使用陣列名和指標運算

#include "iostream"
using namespace std;
int main() {
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    for (int i = 0; i < 10; i++)
        cout << *(a+i) << "  ";
    cout << endl;
    return 0;
}

方法3：使用指標變數

#include "iostream"
using namespace std;
int main() {
    int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    for (int *p = a; p < (a + 10); p++)
        cout << *p << "  ";
    cout << endl;
    return 0;
}

指標與函式

以指標作為函式引數

為什麼需要用指標做引數？

需要資料雙向傳遞時（引用也可以達到此效果）
用指標作為函式的引數，可以使被調函式通過形參指標存取主調函式中實參指標指向的資料，實現資料的雙向傳遞
需要傳遞一組資料，只傳首地址執行效率比較高
實參是陣列名時形參可以是指標

指標型別的函式

（1）不要將非靜態區域性地址用作函式的返回值

（2）例子

#include "iostream"
using namespace std;

int *search(int *a,int num)
{
    for(int i=0;i<10;i++)
    {
        if(a[i]==0)
            return &a[i];
    }
}

int main()
{
    int arr[10];
    int *search(int *a,int num);
    for(int i=0;i<10;i++){
        cin >> arr[i];
    }
    int *zeroptr= search(arr,10);
    return 0;
}

指向函式的指標

（1）定義形式
儲存型別資料型別 (*函式指標名)();

（2）含義
函式指標指向的是程式程式碼儲存區。
（3）用途

實現函式回撥

通過函式指標呼叫的函式
例如將函式的指標作為引數傳遞給一個函式，使得在處理相似事件的時候可以靈活的使用不同的方法。
呼叫者不關心誰是被呼叫者
需知道存在一個具有特定原型和限制條件的被呼叫函式。

物件指標

（1）定義
類名 *物件指標名；

（2）例

Point a(5,10);
Piont *ptr;
ptr=&a;

（3）通過指標訪問物件成員
物件指標名->成員名
例：ptr->getx() 相當於** (*ptr).getx();**

（4）舉例

#include <iostream>
using namespace std;

class Point {
public:
    Point(int x = 0, int y = 0) : x(x), y(y) { }
    int getX() const { return x; }
    int getY() const { return y; }
private:
    int x, y;
};
int main() {
    Point a(4, 5);
    Point *p1 = &a; //定義物件指標，用a的地址初始化
    cout << p1->getX() << endl;//用指標訪問物件成員
    cout << a.getX() << endl; //用物件名訪問物件成員
    return 0;
}
輸出：
4
4

this指標

指向當前物件自己
隱含於類的每一個非靜態成員函式中
指出成員函式所操作的物件
當通過一個物件呼叫成員函式時，系統先將該物件的地址賦給this指標，然後呼叫成員函式，成員函式對物件的資料成員進行操作時，就隱含使用了this指標。
例如：Point類的getX函式中的語句：return x;
相當於： return this->x;
例

class Fred; //前向引用宣告
class Barney {
    Fred *x;
};
class Fred {
    Barney y;
};

動態記憶體分配

分配與釋放

（1）動態申請記憶體操作符 new
new 型別名T（初始化引數列表）
功能：在程式執行期間，申請用於存放T型別物件的記憶體空間，並依初值列表賦以初值。
結果值：成功：T型別的指標，指向新分配的記憶體；失敗：丟擲異常。

（2）釋放記憶體操作符delete
delete 指標p
功能：釋放指標p所指向的記憶體。p必須是new操作的返回值。

（3）舉例

#include <iostream>
using namespace std;

class Point {
public:
    Point() : x(0), y(0) {
        cout<<"Default Constructor called."<<endl;
    }
    Point(int x, int y) : x(x), y(y) {
        cout<< "Constructor called."<<endl;
    }
    ~Point() { cout<<"Destructor called."<<endl; }
    int getX() const { return x; }
    int getY() const { return y; }
    void move(int newX, int newY) {
        x = newX;
        y = newY;
    }
private:
    int x, y;
};

int main() {
    cout << "Step one: " << endl;
    Point *ptr1 = new Point; //呼叫預設建構函式
    delete ptr1; //刪除物件，自動呼叫解構函式
    cout << "Step two: " << endl;
    ptr1 = new Point(1,2);
    delete ptr1;
    return 0;
}
輸出：
Step one:
Default Constructor called.
Destructor called.
Step two:
Constructor called.
Destructor called.

動態陣列

動態多維陣列

智慧指標

顯式管理記憶體在是能上有優勢，但容易出錯。
C++11提供智慧指標的資料型別，對垃圾回收技術提供了一些支援，實現一定程度的記憶體管理
三類：
unique_ptr ：不允許多個指標共享資源，可以用標準庫中的move函式轉移指標
shared_ptr ：多個指標共享資源
weak_ptr ：可複製shared_ptr，但其構造或者釋放對資源不產生影響

vector物件

（1）為什麼需要vector？
封裝任何型別的動態陣列，自動建立和刪除。
陣列下標越界檢查。

（2）vector物件的定義
vector<元素型別> 陣列物件名(陣列長度);

（3）例：

vector<int> arr(5)//建立大小為5的int陣列

vector物件的使用

（1）對陣列元素的引用
與普通陣列具有相同形式：vector物件名 [ 下標表示式 ]

（2）vector陣列物件名不表示陣列首地址
獲得陣列長度用size函式：陣列物件名.size()

（3）舉例：

#include <iostream>
#include <vector>
using namespace std;

//計算陣列arr中元素的平均值
double average(const vector<double> &arr) //vector的引用
{
    double sum = 0;
    for (unsigned i = 0; i<arr.size(); i++)
        sum += arr[i];
    return sum / arr.size();
}
int main() {
    unsigned n;
    cout << "n = ";
    cin >> n;
    vector<double> arr(n); //建立陣列物件
    cout << "Please input " << n << " real numbers:" << endl;
    for (unsigned i = 0; i < n; i++)
        cin >> arr[i];
    cout << "Average = " << average(arr) << endl;
    return 0;
}
輸出：
n = 5
Please input 5 real numbers:
1
2
3
4
6
Average = 3.2

深拷貝

淺層複製

實現物件間資料元素的一一對應複製。
舉例：

#include <iostream>
#include <cassert>
using namespace std;

class Point {
//類的宣告同例6-16
//……
};
class ArrayOfPoints {
//類的宣告同例6-18
//……
};

int main() {
    int count;
    cout << "Please enter the count of points: ";
    cin >> count;
    ArrayOfPoints pointsArray1(count); //建立物件陣列
    pointsArray1.element(0).move(5,10);
    pointsArray1.element(1).move(15,20);
    ArrayOfPoints pointsArray2(pointsArray1); //建立副本
    cout << "Copy of pointsArray1:" << endl;
    cout << "Point_0 of array2: " << pointsArray2.element(0).getX() << ", "
         << pointsArray2.element(0).getY() << endl;
    cout << "Point_1 of array2: " << pointsArray2.element(1).getX() << ", "
         << pointsArray2.element(1).getY() << endl;
    pointsArray1.element(0).move(25, 30);
    pointsArray1.element(1).move(35, 40);
    cout<<"After the moving of pointsArray1:"<<endl;
    cout << "Point_0 of array2: " << pointsArray2.element(0).getX() << ", "
         << pointsArray2.element(0).getY() << endl;
    cout << "Point_1 of array2: " << pointsArray2.element(1).getX() << ", "
         << pointsArray2.element(1).getY() << endl;
    return 0;
}
執行結果如下：
Please enter the number of points:2
Default Constructor called.
Default Constructor called.
Copy of pointsArray1:
Point_0 of array2: 5, 10
Point_1 of array2: 15, 20
After the moving of pointsArray1:
Point_0 of array2: 25, 30
Point_1 of array2: 35, 40
Deleting...
Destructor called.
Destructor called.
Deleting...
接下來程式出現執行錯誤。

深層複製

當被複制的物件資料成員是指標型別時，不是複製該指標成員本身，而是將指標所指物件進行復制。

當返回的物件含有動態建立的空間時，需要用深層複製

#include <iostream>
#include <cassert>
using namespace std;

class Point { //類的宣告同例6-16
};
class ArrayOfPoints {
public:
    ArrayOfPoints(const ArrayOfPoints& pointsArray);
//其他成員同例6-18
};
ArrayOfPoints::ArrayOfPoints(const ArrayOfPoints& v) {
    size = v.size;
    points = new Point[size];//重新建立空間
    for (int i = 0; i < size; i++)
        points[i] = v.points[i];
}
int main() {
//同例6-20
}
程式的執行結果如下：
Please enter the number of points:2
Default Constructor called.
Default Constructor called.
Default Constructor called.
Default Constructor called.
Copy of pointsArray1:
Point_0 of array2: 5, 10
Point_1 of array2: 15, 20
After the moving of pointsArray1:
Point_0 of array2: 5, 10
Point_1 of array2: 15, 20
Deleting...
Destructor called.
Destructor called.
Deleting...
Destructor called.
Destructor called.

移動建構函式

在現實中有很多這樣的例子，我們將錢從一個賬號轉移到另一個賬號，將手機SIM卡轉移到另一臺手機，將檔案從一個位置剪下到另一個位置……移動構造可以減少不必要的複製，帶來效能上的提升。

C++11標準中提供了一種新的構造方法——移動構造。
C++11之前，如果要將源物件的狀態轉移到目標物件只能通過複製。在某些情況下，我們沒有必要複製物件——只需要移動它們。
C++11引入移動語義：源物件資源的控制權全部交給目標物件

問題

當臨時物件在被複制後，就不再被利用了。我們完全可以把臨時物件的資源直接移動，這樣就避免了多餘的複製操作。

移動構造

什麼時候該觸發移動構造？
有可被利用的臨時物件

移動建構函式:class_name ( class_name && )

字串

字元陣列

字串常量
例："program"
各字元連續、順序存放，每個字元佔一個位元組，以‘\0’結尾，相當於一個隱含建立的字元常量陣列
“program”出現在表示式中，表示這一char陣列的首地址
首地址可以賦給char常量指標：
const char *STRING1 = "program";

缺點

執行連線、拷貝、比較等操作，都需要顯式呼叫庫函式，很麻煩
當字串長度很不確定時，需要用new動態建立字元陣列，最後要用delete釋放，很繁瑣
字串實際長度大於為它分配的空間時，會產生陣列下標越界的錯誤

string

使用字串類string表示字串
string實際上是對字元陣列操作的封裝

建構函式

（1）string(); //預設建構函式，建立一個長度為0的串
例：
string s1;

（2）string(const char *s); //用指標s所指向的字串常量初始化string物件
例：
string s2 = “abc”;

（3）string(const string& rhs); //複製建構函式
例：
string s3 = s2;

常用操作

s + t 將串s和t連線成一個新串
s = t 用t更新s
s == t 判斷s與t是否相等
s != t 判斷s與t是否不等
s < t 判斷s是否小於t（按字典順序比較）
s <= t 判斷s是否小於或等於t （按字典順序比較）
s > t 判斷s是否大於t （按字典順序比較）
s >= t 判斷s是否大於或等於t （按字典順序比較）
s[i] 訪問串中下標為i的字元

例：

string s1 = "abc", s2 = "def";
string s3 = s1 + s2; //結果是"abcdef"
bool s4 = (s1 < s2); //結果是true
char s5 = s2[1]; //結果是'e'

getline

如何輸入整行字串？
用cin的>>操作符輸入字串，會以空格作為分隔符，空格後的內容會在下一回輸入時被讀取

getline可以輸入整行字串（要包string標頭檔案），例如：getline(cin, s2);
輸入字串時，可以使用其它分隔符作為字串結束的標誌（例如逗號、分號），將分隔符作為getline的第3個引數即可，例如：getline(cin, s2, ',');

程式

陣列

存放陣列

求Fibonacci數列的前20項

#include <iostream>
using namespace std;

int main() {
    int i;
    int f[20] = {1,1}; //初始化第0、1個數
    for (i = 2; i < 20; i++) //求第2～19個數
        f[i] = f[i - 2] + f[i - 1];
    for (i=0;i<20;i++) { //輸出，每行5個數
        if (i % 5 == 0) cout << endl;
        cout.width(12); //設定輸出寬度為12
        cout << f[i];
    }
    return 0;
}
輸出：
           1           1           2           3           5
           8          13          21          34          55
          89         144         233         377         610
         987        1597        2584        4181        6765

統計正確率

迴圈從鍵盤讀入若干組選擇題答案，計算並輸出每組答案的正確率，直到輸入ctrl+z為止。每組連續輸入5個答案，每個答案可以是'a','b','c','d'。

#include <iostream>
using namespace std;

int main() {
    const char key[ ] = {'a','c','b','a','d'};
    const int NUM_QUES = 5;
    char c;
    int ques = 0, numCorrect = 0;
    cout << "Enter the " << NUM_QUES << " question tests:" << endl;
    while(cin.get(c)) //cin.get(c)得到的是輸出流，所以只需要一次輸入
    {
        if(c != '\n') {
            if(c == key[ques]) {
                numCorrect++; cout << " ";
            } else
                cout<<"*";
            ques++;
        } else {
            cout << " Score " << static_cast<float>(numCorrect)/NUM_QUES*100 << "%";
            ques = 0;  numCorrect = 0; cout << endl;
        }
    }
    return 0;
}
輸出：
Enter the 5 question tests:
abcda
 **** Score 20%
abcad
 **   Score 60%
cabcd
** *  Score 40%
ddaca
***** Score 0%

使用陣列名作為函式引數

主函式中初始化一個二維陣列，表示一個矩陣，矩陣，並將每個元素都輸出，然後呼叫子函式，分別計算每一行的元素之和，將和直接存放在每行的第一個元素中，返回主函式之後輸出各行元素的和。

#include <iostream>
using namespace std;

void rowSum(int a[][4], int nRow) {
    for (int i = 0; i < nRow; i++) {
        for(int j = 1; j < 4; j++)
            a[i][0] += a[i][j];
    }
}
int main() {   //主函式
    //定義並初始化陣列
    int table[3][4] = {{1, 2, 3, 4}, {2, 3, 4, 5}, {3, 4, 5, 6}};
    //輸出陣列元素
    for (int i = 0; i < 3; i++)  {
        for (int j = 0; j < 4; j++)
            cout << table[i][j] << "   ";
        cout << endl;
    }
    rowSum(table, 3);  //呼叫子函式，傳入的是陣列名，計算各行和
    //輸出計算結果
    for (int i = 0; i < 3; i++)
        cout << "Sum of row " << i << " is " << table[i][0] << endl;
    return 0;
}
輸出：
1   2   3   4   
2   3   4   5   
3   4   5   6   
Sum of row 0 is 10
Sum of row 1 is 14
Sum of row 2 is 18

物件陣列應用

//Point.h
#ifndef _POINT_H
#define _POINT_H
class Point { //類的定義
public: //外部介面
    Point();
    Point(int x, int y);
    ~Point();
    void move(int newX,int newY);
    int getX() const { return x; }
    int getY() const { return y; }
    static void showCount(); //靜態函式成員
private: //私有資料成員
    int x, y;
};
#endif //_POINT_H

//Point.cpp
#include <iostream>
#include "Point.h"
using namespace std;
Point::Point() : x(0), y(0) {
    cout << "Default Constructor called." << endl;
}
Point::Point(int x, int y) : x(x), y(y) {
    cout << "Constructor called." << endl;
}
Point::~Point() {
    cout << "Destructor called." << endl;
}
void Point::move(int newX,int newY) {
    cout << "Moving the point to (" << newX << ", " << newY << ")" << endl;
    x = newX;
    y = newY;
}

#include "Point.h"
#include <iostream>
using namespace std;
int main() {
    cout << "Entering main..." << endl;
    Point a[2];
    for(int i = 0; i < 2; i++)
        a[i].move(i + 10, i + 20);
    cout << "Exiting main..." << endl;
    return 0;
}
輸出：
Entering main...
Default Constructor called.
Default Constructor called.
Moving the point to (10, 20)
Moving the point to (11, 21)
Exiting main...
Destructor called.
Destructor called.

指標

void指標

#include <iostream>
using namespace std;

int main() {
//!void voidObject; 錯，不能宣告void型別的變數
    void *pv; //對，可以宣告void型別的指標
    int i = 5;
    pv = &i; //void型別指標指向整型變數
    int *pint = static_cast<int *>(pv); //void指標轉換為int指標
    cout << "*pint = " << *pint << endl;
    return 0;
}
輸出：
*pint = 5

指標表示矩陣

#include "iostream"
using namespace std;

int main()
{
    int line1[]={1,0,1};
    int line2[]={1,0,1};
    int line3[]={1,0,1};

    //定義整型指標陣列並初始化
    int *pline[3]={line1,line2,line3};
    cout <<"矩陣："<< endl;

    //輸出
    for(int i=0;i<3;i++)
    {
        for(int j=0;j<3;j++)
        {
            cout <<pline[i][j]<<" ";
        }
        cout << endl;
    }
    return 0;
}
輸出：
矩陣：
1 0 1
1 0 1
1 0 1

指標做形參

讀入三個浮點數，將整數部分和小數部分分別輸出

#include "iostream"
using namespace std;

void splitFloat(float x, int *intPart, float *fracPart) {
    *intPart = static_cast<int>(x); //取x的整數部分
    *fracPart = x - *intPart; //取x的小數部分
}
int main() {
    cout << "Enter 3 float point numbers:" << endl;
    for(int i = 0; i < 3; i++) {
        float x, f;
        int n;
        cin >> x;
        splitFloat(x, &n, &f);	//變數地址作為實參
        cout << "Integer Part = " << n <<endl<< "Fraction Part = " << f << endl;
    }
    return 0;
}

指向常量的指標做形參

#include "iostream"
using namespace std;

const int N = 6;
void print(const int *p, int n);
int main() {
    int array[N];
    for (int i = 0; i < N; i++)
        cin>>array[i];
    print(array, N);
    return 0;
}
void print(const int *p, int n) {
    cout << "{ " << *p;
    for (int i = 1; i < n; i++)
        cout << ", " << *(p+i);
    cout << " }" << endl;
}
輸出：
1
2
3
4
5
6
{ 1, 2, 3, 4, 5, 6 }

函式指標

編寫一個計算函式compute，對兩個整數進行各種計算。有一個形參為指向具體演算法函式的指標，根據不同的實參函式，用不同的演算法進行計算。編寫三個函式：求兩個整數的最大值、最小值、和。分別用這三個函式作為實參，測試compute函式

#include <iostream>
using namespace std;

int compute(int a, int b, int(*func)(int, int))
{ return func(a, b);}
int max(int a, int b) // 求最大值
{ return ((a > b) ? a: b);}
int min(int a, int b) // 求最小值
{ return ((a < b) ? a: b);}
int sum(int a, int b) // 求和
{ return a + b;}

int main()
{
    int a, b, res;
    cout << "請輸入整數a："; cin >> a;
    cout << "請輸入整數b："; cin >> b;
    res = compute(a, b, & max);
    cout << "Max of " << a << " and " << b << " is " << res << endl;
    res = compute(a, b, & min);
    cout << "Min of " << a << " and " << b << " is " << res << endl;
    res = compute(a, b, & sum);
    cout << "Sum of " << a << " and " << b << " is " << res << endl;
}
輸出：
請輸入整數a：12
請輸入整數b：32
Max of 12 and 32 is 32
Min of 12 and 32 is 12
Sum of 12 and 32 is 44

動態陣列類

#include <iostream>
#include <cassert>
using namespace std;
class Point { //類的宣告同例6-16 … };
    class ArrayOfPoints { //動態陣列類
    public:
        ArrayOfPoints(int size) : size(size) {
            points = new Point[size];
        }
        ~ArrayOfPoints() {
            cout << "Deleting..." << endl;
            delete[] points;
        }
        Point& element(int index) {
            assert(index >= 0 && index < size);
            return points[index];
        }
    private:
        Point *points; //指向動態陣列首地址
        int size; //陣列大小
    };
    
int main() {
    int count;
    cout << "Please enter the count of points: ";
    cin >> count;
    ArrayOfPoints points(count); //建立陣列物件
    points.element(0).move(5, 0); //訪問陣列元素的成員
    points.element(1).move(15, 20); //訪問陣列元素的成員
    return 0;
}
執行結果：
Please enter the number of points:2
Default Constructor called.
Default Constructor called.
Deleting...
Destructor called.
Destructor called.

vector陣列

#include <vector>
#include <iostream>

int main()
{
    std::vector<int> v = {1,2,3};
    for(auto i = v.begin(); i != v.end(); ++i)
        std::cout << *i << std::endl;
    for(auto e : v)//帶範圍的for迴圈
        std::cout << e << std::endl;
}

移動構造

函式返回含有指標成員的物件

（1）先給出使用深層複製建構函式，返回時構造臨時物件，動態分配將臨時物件返回到主調函式，然後刪除臨時物件。

#include<iostream>
using namespace std;

class IntNum {
public:
    IntNum(int x = 0) : xptr(new int(x)){ //建構函式
        cout << "Calling constructor..." << endl;
    }
    //n是引數物件的引用；*n.xptr取值；xptr(new int(*n.xptr)是深拷貝
    IntNum(const IntNum & n) : xptr(new int(*n.xptr)){//複製建構函式
        cout << "Calling copy constructor..." << endl;
    };
    ~IntNum(){ //解構函式
        delete xptr;
        cout << "Destructing..." << endl;
    }
    int getInt() { return *xptr; }
private:
    int *xptr;
};
//返回值為IntNum類物件
IntNum getNum() {
    IntNum a;//新建一個區域性物件，呼叫建構函式
    return a; //返回一個物件，呼叫複製建構函式
}
int main() {
    IntNum p=getNum();
    cout<<p.getInt()<<endl;
    return 0;
}
輸出：
Calling constructor...
Calling copy constructor...
Destructing...
0
Destructing...

（2）使用移動建構函式，將要返回的區域性物件轉移到主調函式，省去了構造和刪除臨時物件的過程。

#include<iostream>
using namespace std;

class IntNum {
public:
    IntNum(int x = 0) : xptr(new int(x)){ //建構函式
        cout << "Calling constructor..." << endl;
    }
    IntNum(const IntNum & n) : xptr(new int(*n.xptr)){//複製建構函式
        cout << "Calling copy constructor..." << endl;
        //注：•&&是右值引用；•函式返回的臨時變數是右值
    }
    IntNum(IntNum && n): xptr( n.xptr){ //移動建構函式
        n.xptr = nullptr;
        cout << "Calling move constructor..." << endl;
    }
    ~IntNum(){ //解構函式
        delete xptr;
        cout << "Destructing..." << endl;
    }
    int getInt() { return *xptr; }
private:
    int *xptr;
};
//返回值為IntNum類物件
IntNum getNum() {
    IntNum a;
    return a;
}
int main() {
    cout << getNum().getInt() << endl; return 0;
}
輸出：
Calling constructor...
Calling move constructor...
Destructing...
0
Destructing...

上面兩個程式輸出是有問題的，待解決！

字串

string

#include <string>
#include <iostream>
using namespace std;

//根據value的值輸出true或false
//title為提示文字
inline void test(const char *title, bool value)
{
    cout << title << " returns "
         << (value ? "true" : "false") << endl;
}
int main() {
    string s1 = "DEF";
    cout << "s1 is " << s1 << endl;
    string s2;
    cout << "Please enter s2: ";
    cin >> s2;
    cout << "length of s2: " << s2.length() << endl;
//比較運算子的測試
    test("s1 <= \"ABC\"", s1 <= "ABC");
    test("\"DEF\" <= s1", "DEF" <= s1);
//連線運算子的測試
    s2 += s1;
    cout << "s2 = s2 + s1: " << s2 << endl;
    cout << "length of s2: " << s2.length() << endl;
    return 0;
}
輸出：
s1 is DEF
Please enter s2: eqwe
length of s2: 4
s1 <= "ABC" returns false
"DEF" <= s1 returns true
s2 = s2 + s1: eqweDEF
length of s2: 7

getline

#include <iostream>
#include <string>
using namespace std;
int main() {
    for (int i = 0; i < 2; i++){
        string city, state;
        getline(cin, city, ',');
        getline(cin, state);
        cout << "City:" << city << ",State:" << state << endl;
    }
    return 0;
}
輸出：
San Francisco,the United States
City:San Francisco,State:the United States
        Beijing,China
City:Beijing,State:China

習題

（1）以下關於地址和指標的敘述中正確的是

可以取變數的地址賦值給同型別的指標變數（對）
可以取常量的地址賦值給同型別的指標變數
可以取一個指標變數的地址賦給本指標變數，這樣就使得指標變數指向自身
所有指標變數如果未賦初值，則自動賦空值NULL

解析：A選項正確。常量儲存在編譯檔案中，不能取地址。B選項錯誤。一個指標變數的地址只能賦給指向這種型別的指標變數，與其本身型別不同，不能賦值，C選項錯誤。未賦初值的指標變數自動賦任意地址值，D選項錯誤。
（2）要定義一個引用變數p使之引用類MyClass的一個物件,正確的定義語句是

MyClass p=MyClass;
MyClass p=new MyClass;
MyClass ＆p=new MyClass;
MyClass a, ＆p=a;（對），別名

（3）在C++的動態儲存分配，下列說法正確的是？

new和delete是C++語言中專門用於動態記憶體分配和釋放的函式
動態分配的記憶體空間也可以被初始化（對）
當系統記憶體不夠時，會自動回收不再使用的記憶體單元，因此程式中不必用delete釋放記憶體空間
當動態分配記憶體失敗時，系統會立刻崩潰，因此一定要慎用new
分析：選項A，錯，new 與delete是用於動態平衡分配與釋放空間的運算子，不是函式;選項C，錯，要使用delete釋放空間，系統會統一管理，而不用delete釋放的空間，會造成記憶體洩漏，這種程式用的次數多，會造成記憶體耗盡;選項D，錯，不成功，會返回0。
（4）C++11中，＆表示左值引用；＆＆表示右值引用——下列關於左值和右值的說法正確的是
表示式等號左邊的是左值，等號右邊的是右值
左值是指表示式結束後依然存在的持久物件（對）
右值是指表示式結束後依然存在的持久物件
可以對右值取地址
分析：左值和右值都是針對表示式而言的，左值是指表示式結束後依然存在的持久物件，右值指表示式結束時就不再存在的臨時物件——顯然右值不可以被取地址。

實驗3 c++
2024-11-10
C++
C++入門（3）：C++開發環境搭建
2021-03-04
C++開發環境
C++ 3/5 法則相關
2024-09-15
C++
c++簡單程式設計-3
2020-04-04
C++程式設計
c++ 計算mp3時長
2024-07-13
C++
Effective C++ 筆記（3）資源管理
2018-06-25
C++筆記
C++整理3_過載及其相關
2024-10-20
C++
我的隨行筆記3 C++ Primer Plus 3--指標
2020-08-27
筆記C++指標
C++ 學習筆記（3）：引用和指標
2024-12-01
C++筆記指標
C++基礎知識學習筆記（3）
2024-05-25
C++筆記
C++入門教程（3）：語句和縮排
2019-05-12
C++
C++回聲伺服器_3-UDP版本
2019-02-26
C++伺服器UDP
C++(3-2 ) 3D-3D ICP SVD RANSCE 官方程式碼參考
2024-08-11
C++3D
c++ Cmake工程（3）平行目錄 opevslam工程模式
2024-08-14
C++SLAM模式
物件導向程式設計(C++篇3)——析構
2022-03-16
物件程式設計C++
C++順序結構（3）、資料型別_____教學
2024-10-18
C++資料型別
Coursera課程筆記----C++程式設計----Week3
2020-05-15
筆記C++程式設計
使用 C++ 呼叫 YOLOv3 模型進行物體檢測
2024-12-05
C++YOLO模型
關於c++使用toml plusplus(俗稱toml++)的使用(3)
2024-08-18
C++TOML
【C++】使用 libass，完成 Direct3D 11 下的字幕渲染
2021-08-12
C++3D
《Effective C++》第三版-3. 資源管理（Resource Management）
2024-04-30
C++
C++理論梳理3——深刻理解標頭檔案的作用
2020-10-12
C++
《C++程式與設計》（第 3 版）課堂作業 Work 12
2020-12-26
C++
TIOBE 9 月排行榜：C++ 式微，第 3 名被 Python 拿下
2018-09-05
C++Python
【C++】C++基礎知識
2024-09-26
C++
【C++】C++之Lambda表示式
2020-12-05
C++
C++
2024-12-09
C++
Roslyn+T4+EnvDTE專案完全自動化(3) ——生成c++程式碼
2022-01-03
ROSC++
2020年騰訊實習生C++面試題&持續更新中（3）
2020-05-16
C++面試題
【C++】外傳篇 3_動態記憶體申請的結果
2019-05-10
C++記憶體
TIOBE 9月排行榜：C++式微第3名被Python拿下
2018-09-06
C++Python
【C++】C++的位元組對齊
2024-04-09
C++
【C++】C++之型別轉換
2020-12-30
C++型別
【C++】 C++知識點總結
2021-04-11
C++
[C++之旅] 7 C++類和物件
2018-11-24
C++物件
學懂現代C++——《Effective Modern C++》之轉向現代C++
2023-09-28
C++
C++資料格式化3 - 格式化時間區間(使用時長)
2024-06-18
C++
C++核心程式設計---3.函式高階【P95~P98】
2021-01-01
C++程式設計函式

c++：-3

陣列

定義和初始化

定義

使用

儲存

初始化

傳參

物件陣列

定義和訪問

初始化

基於範圍的for迴圈

原for迴圈

新for迴圈

指標

定義

初始化

賦值

指標空值nullptr

指向常量的指標

指標型別的常量

運算

算術運算

關係運算

指標與陣列

用指標訪問陣列

指標與函式

以指標作為函式引數

指標型別的函式

指向函式的指標

物件指標

this指標

動態記憶體分配

分配與釋放

動態陣列

動態多維陣列

智慧指標

vector物件

vector物件的使用

深拷貝

淺層複製

深層複製

移動建構函式

問題

移動構造

字串

字元陣列

缺點

string

建構函式

常用操作

getline

程式

陣列

存放陣列

統計正確率

使用陣列名作為函式引數

物件陣列應用

指標

void指標

指標表示矩陣

指標做形參

函式指標

動態陣列類

vector陣列

移動構造

字串

string

getline

習題

相關文章