1.6 cpp的常見特性

1.6 cpp的常見特性

---

返回目錄 1 面向對象技術
上一節 1.5 結構體和類
下一節 1.7 cpp中類的常見特性

---

bool類型

c++中擴充了一種新的數據類型：bool類型。

bool類型中只有兩種可能的值：true或者false，分別表示真、假。

源代碼

/* bool.cpp bool類型實例 */
#include <iostream>

int main()
{

    bool go_out = false, go_home = true;

    if (go_out)
    {
        std::cout << "今天出門。" << std::endl;
    }
    else
    {
        std::cout << "今天不出門。" << std::endl;
    }
    
    if (go_home)
    {
        std::cout << "今天回家。" << std::endl;
    }
    else
    {
        std::cout << "今天不回家。" << std::endl;
    }

    return 0;

}

編譯運行

今天不出門。
今天回家。

std:string

std::string是c++的字符串，須要：

#include <string>

string其實是c++標準庫中的一個類，定義產生的字符串實際上是一個對象。

源代碼

/* string.cpp string實例 */
#include <iostream>
#include <string>

int main()
{

    /* 定義字符串開始 */
    std::string str_1;
    str_1 = "111：這是第一部分字符串_";

    std::string str_2 = "12：這是第二部分字符串_";

    std::string str_3("113：這是第三部分字符串_");

    std::string str_4(3, '6');

    std::string str_5 = str_4;
    /* 定義字符串結束 */

    std::cout << str_1 + str_2 + str_3 + str_4 << std::endl; // 字符串鏈接

    std::cout << "str_5中的的第2個字符是：" << str_5[1] << std::endl; // []操做符訪問字符串

    /* 字符串比較大小 */
    std::cout << "str_1比str_2大：" << (str_1 > str_2) << std::endl;
    std::cout << "str_2比str_3小：" << (str_2 < str_3) << std::endl;
    std::cout << "str_3和str_4不一樣：" << (str_3 != str_4) << std::endl;
    std::cout << "str_4和str_5相同：" << (str_4 == str_5) << std::endl;
    /* 字符串比較大小結束 */

    std::cout << "str_1 size:" << str_1.size() << std::endl;
    std::cout << "str_4 length:" << str_4.length() << std::endl;

    return 0;

}

編譯運行

111：這是第一部分字符串_12：這是第二部分字符串_113：這是第三部分字符串_666
str_5中的的第2個字符是：6
str_1比str_2大：0
str_2比str_3小：0
str_3和str_4不一樣：1
str_4和str_5相同：1
str_1 size:24
str_4 length:3

string是一個類，其中封裝了許多實用的函數用於執行許多便捷的操做，能夠自行查閱相關函數。

注意：數據類型爲bool時，true值輸出1，false值輸出0；

對string對象使用'>'或者'<'符號，實際比較的是字符串中按照字符順序從左到右的大小。

如:

Cb > Ca

Fi > Faa

12 > 111

指針和引用

引用是c++的新特性，在一些狀況下，咱們能夠避免使用指針而使用引用。可是本質上，引用仍然是指針。

源代碼

/* reference.cpp 指針和引用實例 */
#include <iostream>

void swap_pointer(int* num_1, int* num_2) // 指針交換整數的函數
{
    int median_num;

    median_num = *num_1;
    *num_1 = *num_2;
    *num_2 = median_num;
}

void swap_reference(int& num_1, int& num_2) // 引用交換整數的函數
{
    int median_num;

    median_num = num_1;
    num_1 = num_2;
    num_2 = median_num;

}

void display_infos(std::string str_display, int num_1, int num_2)
{
    std::cout <<str_display << std::endl;
    std::cout << "num_1:" << num_1 << std::endl;
    std::cout << "num_2:" << num_2 << std::endl;
    std::cout << std::endl;
}

int main()
{

    int num_1 = 2, num_2 = 3;
    display_infos("初始值：", num_1, num_2);

    swap_pointer(&num_1, &num_2);
    display_infos("指針交換初始值：", num_1, num_2);

    swap_reference(num_1, num_2);
    display_infos("引用再交換已經交換一次後的值：", num_1, num_2);

    return 0;

}

編譯運行

初始值：
num_1:2
num_2:3

指針交換初始值：
num_1:3
num_2:2

引用再交換已經交換一次後的值：
num_1:2
num_2:3

引用其實是給變量起了一個「別名」。

本質上引用仍是對地址的操做，可是看起來咱們沒必要糾結於"*"，而是直接操做「普通變量」。這樣，就下降了指針在視覺上的複雜度。

const

const的做用是使被其修飾的變量沒法被修改，能夠看做是常量。

在c++中使用引用，咱們能夠輕鬆地爲一個變量起別名：

int a = 3;
int &b = a;

這種狀況下，對a或者b的操做都會影響到它們指向的那一片內存空間。

由於b至關因而a的另一個名字。

可是引用只能用變量來初始化，沒法用常量來初始化：

int &c = 10;

這是不被容許的，想要實現常量初始化引用，就必須用const來修飾：

const int &c = 10;

const對象、變量只能賦值給const對象、變量。

非const對象、變量也能賦值給const對象、變量。

constt對象、變量沒法直接修改。

動態分配內存

C語言中，咱們使用malloc和free來請求和釋放內存空間，須要：

#include <malloc.h>

而在c++中，咱們直接使用new請求內存空間，用delete來釋放內存空間。

源代碼

/* new_delete.cpp c++動態分配內存實例 */
#include <iostream>

int main()
{

    int* num_1 = new int; // 申請一個int空間而且不初始化
    *num_1 = 1; // 賦值

    int* num_2 = new int(2); // 申請一個int空間而且初始化

    int* array_1 = new int[10]; // 申請十個連續的int空間而且不初始化爲默認值
    for (int i = 0; i < 10; i++)
    {
        array_1[i] = 1;
    }
    
    int* array_2 = new int[10](); // 申請十個連續的int空間而且初始化爲默認值，此處只能初始化爲默認值，不容許其它值。

    /* 輸出 */
    std::cout << "num_1：" << *num_1 << std::endl;
    std::cout << "num_2：" << *num_2 << std::endl;
    std::cout << std::endl;
    std::cout << "array_1：" << std::endl;
    for (int i = 0; i < 10; i++)
    {
        std::cout << array_1[i] << std::ends;
    }
    std::cout << std::endl << std::endl;
    std::cout << "array_1：" << std::endl;
    for (int i = 0; i < 10; i++)
    {
        std::cout << array_2[i] << std::ends;
    }
    /* 輸出結束 */

    delete num_1; // 釋放單個的內存空間
    delete num_2;

    delete[] array_1; // 釋放連續的內存空間
    delete[] array_2;

    return 0;

}

編譯運行

num_1：1
num_2：2

array_1：
1 1 1 1 1 1 1 1 1 1

array_1：
0 0 0 0 0 0 0 0 0 0

使用new最重要的是在用完空間之後及時地delete，不然出現內存泄漏，嚴重時會瘋狂佔用系統內存，致使死機。

以前用SDL作了個小遊戲，而後忘了釋放內存，8個G的內存條几分鐘就能爆滿，朋友的筆記本運行了一小會兒直接死機。

固然，終止程序就會釋放內存，可是咱們許多時候是須要程序持續運行的，沒有釋放內存是件很危險的事情。

重載函數

以前在類中提到重載構造函數，這裏再提一下重載函數：

源代碼

/* overload1.cpp 重載函數實例1 */
#include <iostream>

int add_num(int num_1, int num_2)
{
    return num_1 + num_2;
}

double add_num(double num_1, double num_2)
{
    return num_1 + num_2;
}

int main()
{

    std::cout << add_num(1, 1) << std::endl;
    std::cout << add_num(1.1, 1.1) << std::endl;

    return 0;

}

編譯運行

2
2.2

能夠看到，咱們採用了相同的函數名稱，可是修改了函數中的參數數據類型和返回值類型，所以咱們得到了同名的整數相加函數和浮點數相加函數。

當咱們在函數中填入兩個整數，獲得整數和；當咱們在函數中填入兩個浮點數，獲得浮點數和。

這就叫作重載。

函數重載主要依賴於傳入參數的數據類型和參數個數：

源代碼

/* overload2.cpp 重載函數實例2 */
#include <iostream>
#include <string>

std::string str_mycat(std::string str1, std::string str2)
{
    return str1 + str2;
}

std::string str_mycat(std::string str1, std::string str2, std::string str3)
{
    return str1 + str2 + str3;
}

int main()
{

    std::cout << str_mycat("111", "222") <<std::endl;
    std::cout << str_mycat("111", "222", "333") <<std::endl;

    return 0;

}

編譯運行

111222
111222333

---

返回目錄 1 面向對象技術
上一節 1.5 結構體和類
下一節 1.7 cpp中類的常見特性

---

參考資料：

• 《C++程序設計》傳智播客
• 博客園
• CSDN
• 百度百科