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
• 百度百科