C++（一）：基本数据类型

妖狐艹你老母 2024-03-18 00:22 103阅读 0赞

#### 基本数据类型 ####

*   *  基本内置类型
     *  定义变量
     *   *  \`type field = value;\`
         *  \`type field(value);\`
         *  \`type field\{value\};\`
         *  \`type field = \{value\};\`
     *  数学常量及函数
     *  静态类型转换 \`static\_cast\`
     *  格式化字符串
     *   *  \`std::stringstream\`
         *  \`std::string\`
         *  引入三方库 \`fmt/core.h\`
     *  字符运算
     *  \`auto\` 关键字
     *  枚举类型
     *  数据类型定义别名
     *  判断是否为NaN
     *  三向比较运算符（太空飞船运算符）
     *  多维数组
     *  避免幻数
     *  运行期间为数组分配内存空间
     *  数组的替代品
     *   *  \`std::array\`
         *  \`std::vector\`

### 基本内置类型 ###

![在这里插入图片描述][0416cff8779c4f84b86163f4cab1332c.png_pic_center]

#include <iostream>
    
    using namespace std;
    
    int main() {
        
        cout << "数据类型" << "\t\t" << "所占字节" << "\t" << "最小值" << "\t\t\t" << "最大值" << endl;
    
        cout << "bool(布尔型)" << "\t\t" << sizeof(bool) << "\t\t" << numeric_limits<bool>::min() << "\t\t\t" << numeric_limits<bool>::max() << endl;
    
        cout << "char(字符型)" << "\t\t" << sizeof(char) << "\t\t" << numeric_limits<char>::min() << "\t\t\t" << numeric_limits<char>::max() << endl;
        cout << "unsigned char" << "\t\t" << sizeof(unsigned char) << "\t" << numeric_limits<unsigned char>::min() << "\t" << numeric_limits<unsigned char>::max() << endl;
        cout << "signed char" << "\t\t" << sizeof(signed char) << "\t\t" << numeric_limits<signed char>::min() << "\t\t\t" << numeric_limits<signed char>::max() << endl;
    
        cout << "int(整型)" << "\t\t" << sizeof(int) << "\t\t" << numeric_limits<int>::min() << "\t\t" << numeric_limits<int>::max() << endl;
        cout << "unsigned int" << "\t\t" << sizeof(unsigned int) << "\t\t" << numeric_limits<unsigned int>::min() << "\t\t\t" << numeric_limits<unsigned int>::min() << endl;
        cout << "signed int" << "\t\t" << sizeof(signed int) << "\t\t" << numeric_limits<signed int>::min() << "\t\t" << numeric_limits<signed int>::max() << endl;
    
        cout << "short int" << "\t\t" << sizeof(short int) << "\t\t" << numeric_limits<short int>::min() << "\t\t\t" << numeric_limits<short int>::max() << endl;
        cout << "unsigned short int" << "\t" << sizeof(unsigned short int) << "\t\t" << numeric_limits<unsigned short int>::min() << "\t\t\t" << numeric_limits<unsigned short int>::max() << endl;
        cout << "signed short int" << "\t" << sizeof(signed short int) << "\t\t" << numeric_limits<signed short int>::min() << "\t\t\t" << numeric_limits<signed short int>::max() << endl;
    
        cout << "long int" << "\t\t" << sizeof(long int) << "\t\t" << numeric_limits<long int>::min() << "\t" << numeric_limits<long int>::max() << endl;
        cout << "unsigned long int" << "\t" << sizeof(unsigned long int) << "\t\t" << numeric_limits<unsigned long int>::min() << "\t\t\t" << numeric_limits<unsigned long int>::max() << endl;
        cout << "signed long int" << "\t\t" << sizeof(signed long int) << "\t\t" << numeric_limits<signed long int>::min() << "\t" << numeric_limits<signed long int>::max() << endl;
    
        cout << "float(浮点型)" << "\t\t" << sizeof(float) << "\t\t" << numeric_limits<float>::min() << "\t\t" << numeric_limits<float>::max() << endl;
    
        cout << "double(双浮点型)" << "\t" << sizeof(double) << "\t\t" << numeric_limits<double>::min() << "\t\t" << numeric_limits<double>::max() << endl;
    
        cout << "long double" << "\t\t" << sizeof(long double) << "\t\t" << numeric_limits<long double>::min() << "\t\t" << numeric_limits<long double>::max() << endl;
    
        cout << "wchar_t(宽字符型)" << "\t" << sizeof(wchar_t) << "\t\t" << numeric_limits<wchar_t>::min() << "\t\t" << numeric_limits<wchar_t>::max() << endl;
    
        return 0;
    }

### 定义变量 ###

#### `type field = value;` ####

> 这是最常见的初始化语法，使用等号来将value赋值给field。这种方式允许发生隐式类型转换，并且不会进行列表初始化检查。

#include <iostream>
    
    using namespace std;
    
    int main() {
        
        int a = 1;
        int b = 1.5;
        cout << a << endl; // 1
        cout << b << endl; // 1
        return 0;
    }

#### `type field(value);` ####

> 这种初始化方式使用括号进行初始化。它类似于使用等号进行初始化，允许发生隐式类型转换，不进行列表初始化检查。

#include <iostream>
    
    using namespace std;
    
    int main() {
        
        int a(1);
        int b(1.56);
        cout << a << endl; // 1
        cout << b << endl; // 1
        return 0;
    }

#### `type field{value};` ####

> 这种初始化方式使用花括号，被称为列表初始化。它提供了更严格的类型检查，并且不允许发生窄化转换（narrowing conversion）。如果存在可能发生精度损失或信息丢失的情况，编译器会产生错误。

#include <iostream>
    
    using namespace std;
    
    int main() {
        
        int a{
        1}; // int a{1.5}; error
        cout << a << endl; // 1
        return 0;
    }

#### `type field = {value};` ####

> 这种初始化方式也使用等号和花括号，被称为统一初始化。它类似于列表初始化，提供了更严格的类型检查，并且不允许窄化转换。与type field\{value\}; 的区别在于，等号和花括号之间可以有空格。

#include <iostream>
    
    using namespace std;
    
    int main() {
        
        int a = {
        1}; // int a = {1.5}; error
        cout << a << endl; // 1
        return 0;
    }

### 数学常量及函数 ###

![在这里插入图片描述][7e7dac08d9bc4faa9f6e7d19d569b23d.png_pic_center]

#include <iostream>
    #include <numbers>
    
    using namespace std;
    
    int main() {
        
    
        cout << "自然对数的底\t\t\t" << numbers::e << endl;
        cout << "圆周率\t\t\t\t" << numbers::pi << endl;
        cout << "2的平方根\t\t\t" << numbers::sqrt2 << endl;
        cout << "黄金比例常量\t\t\t" << numbers::phi << endl;
    
        cout << "绝对值\t\t\t\t" << abs(-1.23) << endl;
        cout << "大于或等于参数的最小整数\t" << ceil(-1.23) << endl;
        cout << "小于或等于参数的最大整数\t" << floor(-1.23) << endl;
        cout << "计算e^参数\t\t\t" << exp(1) << endl;
        cout << "计算底为e的参数的自然对数\t" << log(exp(1)) << endl;
        cout << "计算底为10的参数的自然对数\t" << log10(100) << endl;
        cout << "幂\t\t\t\t" << pow(2, 10) << endl;
        cout << "平方根\t\t\t\t" << sqrt(9) << endl;
        cout << "四舍五入\t\t\t" << round(-12.54) << endl;
    
        return 0;
    }

### 静态类型转换 `static_cast` ###

> 强制转换为另一种数据类型的值，转换过程中不进行任何运行时类型检查，因此可能导致运行时错误，通常用于比较类型相似的对象之间的转换，如int转float

#include <iostream>
    
    using namespace std;
    
    int main() {
        
    
        float a = 1.23;
        int b = static_cast<int>(a);
    
        cout << a << " 类型：" << typeid(a).name() << endl; // 1.23    类型：f
        cout << b << " 类型：" << typeid(b).name() << endl; // 1       类型：i
    
        return 0;
    }

### 格式化字符串 ###

#### `std::stringstream` ####

#include <iostream>
    #include <sstream>
    
    using namespace std;
    
    int main() {
        
    
        int age = 18;
    
        char name[] = "Lee";
    
        stringstream msg;
    
        msg << "Hello, " << name << "!!! " << age << "!!!";
    
        cout << msg.str() << endl; // Hello, Lee!!! 18!!!
    
        return 0;
    }

#### `std::string` ####

#include <iostream>
    
    using namespace std;
    
    int main() {
        
    
        int age = 18;
    
        string name = "Lee";
    
        string msg = "Hello, " + name + "!!! " + to_string(age) + "!!!";
    
        cout << msg << endl; // Hello, Lee!!! 18!!!
    
        return 0;
    }

#### 引入三方库 `fmt/core.h` ####

***下载***

> [https://github.com/fmtlib/fmt.git][https_github.com_fmtlib_fmt.git]

> ![在这里插入图片描述][5cde57f690464dccaf8f0eaf39e05572.png_pic_center]

***引入 `c-app/CMakeLists.txt`***

cmake_minimum_required(VERSION 3.25)
    project(c_app)
    
    set(CMAKE_CXX_STANDARD 20)
    
    add_executable(c_app ../main.cpp)
    
    # 添加fmt库目录
    add_subdirectory(../libs/fmt-10.0.0)
    
    # 链接fmt库
    target_link_libraries(c_app fmt::fmt)

***运行***

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    int main() {
        
    
        char name[] = "Lee";
    
        double height = 1.8123456;
    
        int age = 18;
    
        string msg = fmt::format("Hello, {}! Height: {:.2f}! Age: {}!", name, height, age);
    
        cout << msg << endl; // Hello, Lee! Height: 1.81! Age: 18!
    
        return 0;
    }

### 字符运算 ###

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    int main() {
        
    
        char word = 'A';
    
        string msg = fmt::format("字符: {} \n表示字符的整数代码: {} \n整数转字符: {}", word, word + 1, static_cast<char>(word + 2));
    
        /**
         * 字符: A
         * 表示字符的整数代码: 66
         * 整数转字符: C
         */
        cout << msg << endl;
    
        return 0;
    }

### `auto` 关键字 ###

> 用于自动推断变量类型

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    int main() {
        
    
        auto a = 1;
        auto b = {
        2};
        auto c{
        3};
    
        /**
         * a: i
         * b: St16initializer_listIiE
         * c: i
         */
        cout << fmt::format("a: {}\nb: {}\nc: {}", typeid(a).name(), typeid(b).name(), typeid(c).name()) << endl;
    
        return 0;
    }

### 枚举类型 ###

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    /**
     * 枚举类型Color
     */
    enum class Color {
        
        red, green = 3, blue
    } color;
    
    /**
     * 枚举类型Mode
     */
    enum class Mode : char {
        
        create = 'C',
        del = 'D',
        edit = 'U',
        search = 'Q'
    };
    
    int main() {
        
    
        cout << static_cast<int>(color) << endl; // 0
    
        color = Color::red;
        cout << static_cast<int>(color) << endl;  // 0
    
        color = Color::green;
        cout << static_cast<int>(color) << endl;  // 3
    
        color = Color::blue;
        cout << static_cast<int>(color) << endl;  // 4
    
        Color c1 = Color::red;
        Color c2 = Color::green;
        Color c3 = Color::blue;
        cout << fmt::format("c1: {}, c2: {}, c3: {}", static_cast<int>(c1), static_cast<int>(c2), static_cast<int>(c3)) << endl; // c1: 0, c2: 3, c3: 4
    
        Mode mode{
        Mode::edit};
    
        cout << fmt::format("mode: {}, {}", static_cast<char>(mode), static_cast<int>(mode)) << endl; // mode: U, 85
    
        return 0;
    }

### 数据类型定义别名 ###

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    // 别名方式1
    using str1 = std::string;
    
    // 别名方式2
    typedef char str2;
    
    int main() {
        
    
        str1 say = "Hello";
        str2 name[] = "Lee";
    
        std::cout << fmt::format("{}, {}!!!", say, name) << std::endl; // Hello, Lee!!!
    
        return 0;
    }

### 判断是否为NaN ###

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    #include <numbers>
    
    using namespace std;
    
    int main() {
        
    
        double pi = numbers::pi;
    
        double num = sqrt(-1);
    
        cout << fmt::format("pi: {}, num: {}", pi, num) << endl; // pi: 3.141592653589793, num: nan
        cout << fmt::format("pi: {}, num: {}", isnan(pi), isnan(num)) << endl; // pi: false, num: true
    
        return 0;
    }

### 三向比较运算符（太空飞船运算符） ###

*  `a <=> b` 返回枚举类型
    
     *  `equal(等于)`
     *  `equivalent(等于)`
     *  `greater(大于)`
     *  `less(小于)`
     *  `unordered(NaN相等)`

<table> 
 <thead> 
  <tr> 
   <th>比较类型</th> 
   <th>less</th> 
   <th>greater</th> 
   <th>equal</th> 
   <th>equivalent</th> 
   <th>unordered</th> 
   <th>用于</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>strong_ordering</td> 
   <td>YES</td> 
   <td>YES</td> 
   <td>YES</td> 
   <td>YES</td> 
   <td>NO</td> 
   <td>整数和指针</td> 
  </tr> 
  <tr> 
   <td>partial_ordering</td> 
   <td>YES</td> 
   <td>YES</td> 
   <td>NO</td> 
   <td>YES</td> 
   <td>YES</td> 
   <td>浮点数</td> 
  </tr> 
  <tr> 
   <td>weak_ordering</td> 
   <td>YES</td> 
   <td>YES</td> 
   <td>NO</td> 
   <td>YES</td> 
   <td>NO</td> 
   <td>仅用于用户自定义的运算符</td> 
  </tr> 
 </tbody> 
</table>

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    int main() {
        
    
        double a = numeric_limits<double>::quiet_NaN(); // nan
        double b = numeric_limits<double>::quiet_NaN(); // nan
    
        partial_ordering c{
        a <=> b};
    
        if (c == strong_ordering::equal) {
        
            cout << "a = b" << endl;
        } else if (c == strong_ordering::equivalent) {
        
            cout << "两个值在强序比较中是等价的" << endl;
        } else if (c == strong_ordering::greater) {
        
            cout << "a > b" << endl;
        } else if (c == strong_ordering::less) {
        
            cout << "a < b" << endl;
        }
    
        if (c == partial_ordering::unordered) {
        
            cout << fmt::format("a: {}, b: {}", isnan(a), isnan(b)) << endl; // a: true, b: true
        }
    
        if (is_eq(c)) {
        
            cout << "a = b" << endl;
        }
    
        if (is_gt(c)) {
        
            cout << "a > b" << endl;
        }
    
        if (is_gteq(c)) {
        
            cout << "a >= b" << endl;
        }
    
        if (is_lt(c)) {
        
            cout << "a < b" << endl;
        }
    
        if (is_lteq(c)) {
        
            cout << "a <= b" << endl;
        }
    
        return 0;
    }

### 多维数组 ###

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    int main() {
        
    
        int list[3][3] = {
        
                {
        1, 2, 3},
                {
        4, 5, 6},
                {
        7, 8, 9}
        };
    
        for (int i = 0; i < size(list); ++i) {
        
            for (int j = 0; j < size(list[i]); ++j) {
        
                cout << fmt::format("{} ", list[i][j]); // 1 2 3 4 5 6 7 8 9
            }
        }
    
        for (auto &a: list) {
        
            for (int b: a) {
        
                cout << fmt::format("{} ", b); // 1 2 3 4 5 6 7 8 9
            }
        }
    
        return 0;
    }

### 避免幻数 ###

> 幻数是指在代码中直接使用一些未经解释的常数值，这样的代码可读性较差，且不易于维护和理解，示例如下：

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    int main() {
        
    
        int list[3]{
        1, 2, 3};
    
        for (int i = 0; i < size(list) + 5; ++i) {
        
            /**
             * 结果：
             *      1 2 3 1 -1445723955 -250088645 0 0
             *      1 2 3 1 1461452947 457358528 0 0
             *      1 2 3 1 805896392 1713566091 0 0
             */
            cout << fmt::format("{} ", list[i]);
        }
    
        return 0;
    }

### 运行期间为数组分配内存空间 ###

> 可变的数组长度

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    int main() {
        
    
        int count;
    
        cin >> count; // 8
    
        int list[count];
    
        for (int i = 0; i < count; ++i) {
        
            list[i] = i + 1;
        }
    
        for (int num: list) {
        
            cout << fmt::format("{} ", num); // 1 2 3 4 5 6 7 8
        }
    
        return 0;
    }

### 数组的替代品 ###

#### `std::array` ####

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    int main() {
        
    
        /* ========= list1 =========*/
    
        array<int, 5> list1 = {
        1, 2, 3, 4, 5};
    
        for (int d: list1) {
        
            cout << d; // 1 2 3 4 5
        }
    
        /* ========= list2 =========*/
    
        auto list2 = array{
        1, 2, 3, 4, 5}; // 根据值推断模版参数
    
        cout << list2.size(); // 5
    
        cout << list2.at(3); // 4
    
        cout << list2[2]; // 3
    
        list2.fill(3);
    
        for (double d: list2) {
        
            cout << d; // 3 3 3 3 3
        }
    
        return 0;
    }

***比较***

*  `相等`：`比较每个元素均相等`
 *  `不等`：`只要存在不等即不等`
 *  `大于`：`第一个元素进行比较然后返回对应判断`
 *  `小于`：`第一个元素进行比较然后返回对应判断`

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    int main() {
        
    
        array<int, 5> l = {
        1, 2, 3, 4, 5};
    
        array<int, 5> a = {
        1, 2, 3, 4, 5}; // l == a
        array<int, 5> b = {
        5, 4, 3, 2, 1}; // l < b
        array<int, 5> c = {
        3, 2, 1, 5, 4}; // l < c
        array<int, 5> d = {
        6, 6, 6, 6, 6}; // l < d
        array<int, 5> e = {
        0, 0, 1, 0, 0}; // l > e
    
        return 0;
    }

#### `std::vector` ####

#include <iostream>
    #include "libs/fmt-10.0.0/include/fmt/core.h"
    
    using namespace std;
    
    int main() {
        
    
        /* ====== list1 ====== */
    
        vector<int> list1 = {
        1, 2, 3, 4, 5};
    
        // push一个元素
        list1.push_back(6);
    
        // 数组长度
        cout << list1.size() << endl; // 6
    
        for (int num: list1) {
        
            cout << num; // 1 2 3 4 5 6
        }
    
        // 删除最后一个元素
        list1.pop_back();
    
        for (int num: list1) {
        
            cout << num; // 1 2 3 4 5
        }
    
        /* ====== list2 ====== */
    
        vector list2(1, 6); // 1 到 6
    
        for (int num: list2) {
        
            cout << num; // 1 2 3 4 5 6
        }
    
        list2.assign(3, 1); // 3 个 1
    
        for (int num: list2) {
        
            cout << num; // 1 1 1
        }
    
        list2.assign({
        6, 2, 3, 4, 5});
    
        for (int num: list2) {
        
            cout << num; // 6 2 3 4 5
        }
    
        /* ====== list3 ====== */
    
        vector<int> list3{
        7, 6, 2, 3, 3, 6, 3, 8};
    
        erase(list3, 3);
        for (int num: list3) {
        
            cout << num; // 7 6 2 6 8
        }
    
        list3.empty(); // 清空但保留长度
        cout << list3.size(); // 5
    
        list3.clear(); // 清空
        cout << list3.size(); // 0
    
        return 0;
    }

[0416cff8779c4f84b86163f4cab1332c.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/b84c7e38fb7e458486319cd499b29ec6.png
[7e7dac08d9bc4faa9f6e7d19d569b23d.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/adf76434412b451b82a21b74cc937ebf.png
[https_github.com_fmtlib_fmt.git]: https://github.com/fmtlib/fmt.git
[5cde57f690464dccaf8f0eaf39e05572.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/6fe8b681ebc04363b91b4613c8b02a33.png