Cpp-1

C++ 简介

bool类型

/*
    bool类型:
        1.用来描述"真"或"假"
        2.取值：true(真)    false(假)
        3.它占1字节（ sizeof(bool) -> 1 ）
*/

内联函数

/*
    <内联函数>
        1.它是函数，这一点是肯定的。
        2.通过“内存膨胀”的方式，以空间换取时间，目的是为了提高程序运行的速度
        3.实现方式：给“函数”和“函数声明”加上关键字“inline”
        4.使用限制：若函数体中的代码太多、或者涉及循环，不建议使用“内联函数”
*/

#include <stdio.h>

inline void func(int num);    // 关键字 inline

int main()
{
    func(6);
    return 0;
}

inline void func(int num)    // 关键字 inline
{
    printf("%d\n", num);
}

函数重载

/*
    <函数重载>
        1.在同一个项目中，定义的函数名字可以重复
        2.函数名必须一致
        3.函数的参数列表不同
        4.返回值无要求
*/

#include <stdio.h>

int func(int num)
{
    return num + 100;
}

float func(float num)
{
    return num;
}

int main()
{
    printf("%d\n", func(66));
    printf("%f\n", func(3.14f));    // 注意“函数重载”的“二义性”问题
    return 0;
}

函数参数缺省

/*
    <参数缺省>
        声明函数某个参数的时候，指定一个默认值，调用该函数时
        如果采用默认值，无需指定该参数

        注意事项：“有函数声明”和“无函数声明”省略参数写法有点不同
*/

// 无函数声明

#include <stdio.h>

int func(int num, float value = 10.0f)    // 对于参数，无默认值的在左，有默认值的在后
{
    return 666;
}

int main()
{
    printf("%d\n", func(5));
    return 0;
}

引用

/*
    <引用>
        1.对一个变量或者对象取的别名
        2.定义引用的时候必须要初始化
*/

#include <stdio.h>


int main()
{
    int playerGameAbility = 9;
    int& pga = playerGameAbility;    // 定义引用，必须要初始化

    // 引用只是个别名，所以说，它和被引用的东西对应的是同一段内存，引用是没有自己的内存的
    printf("%d\n", playerGameAbility);
    pga = 666;
    printf("%d\n", playerGameAbility);

    return 0;
}

命名空间

/*
    <命名空间>
        1.命名空间是用来组织和重用代码的编译单元
        2.通过命名空间，来避免冲突，解决重名现象
        3.命名空间关键字 namespace
        4.作用域运算符 ::
        5.命名空间可以嵌套
*/

#include <stdio.h>

namespace NAME_1
{
    int num = 2;
    void func()
    {
        printf("NAME_1 -> func\n");
    }

    namespace NAME_1_1
    {
        int num = 4;
        void func()
        {
            printf("NAME_1_1 -> func\n");
        }
    }
}

int main()
{
    int num = 6;
    printf("%d \n", NAME_1::num);
    printf("%d \n", NAME_1::NAME_1_1::num);
    printf("%d \n", num);

    return 0;
}


// 下面的空间，还是续接上面的空间
// 这种情况也叫“命名污染”，可以合理利用这个污染，在不同地方，完善同一个命名空间
namespace NAME_1
{
    char a;
    int num;
}

// 命名空间的取别名
namespace A = NAME_1;

cin || cout

cin 和 cout（类似 printf、scanf）

#include <iostream>

int main()
{
    int num;
    std::cin >> num;    // std 空间下的 cin(输入)、cout(输出)、endl(换行)
    std::cout << num << std::endl;

    return 0;
}

#include <iostream>
using namespace std;    // 声明使用 std 空间，以后再使用 cin、cout、endl就不用再强调 std::xxx

int main()
{
    int num;
    cin >> num;
    cout << num << endl;

    return 0;
}

#include <iostream>
using namespace std;

int main()
{
    int a, b, c, d, e, f, g;
    cin >> a >> b >> c >> d >> e >> f >> g;    // 不断输入数据，然后自动将数据分配给 a、b、c...
    cout << a << b << c << d << e << f << g << endl;    // 输出 a、b、c...

    cout << "Hello World!" << endl;

    return 0;
}

#include <iostream>
using std::cin;        // （使用）引入 std 下的 cin
using std::cout;    // （使用）引入 std 下的 cin
using std::endl;    // （使用）引入 std 下的 cin

int main()
{
    cout << "Hello World!" << endl;

    return 0;
}

new || delete

new 和 delete（类似 malloc、free）

#include <iostream>
using namespace std;


int main()
{
    // 1.申请单个内存（用来存放一个整型数据）
    int* p1 = new int;
    *p1 = 15;

    // 2.申请单个内存且初始化
    int* p2 = new int(666);    // 括号里面的666，是你想要在这个内存里面存的整型数据
    cout << *p2 << endl;

    // 3.批量申请（连续的内存）注意！批量申请无法初始化
    int* p3 = new int[10];
    for (int i = 0; i < 10; i++)
    {
        p3[i] = i;    // 赋值
        cout << "p3[" << i << "] = " << p3[i] << endl;    // 输出值
    }
    
    // 释放内存
    delete p1;        // 单个内存的释放
    delete p2;        // 单个内存的释放
    delete[] p3;    // 批量内存的释放


    return 0;
}