C++-01、特性、常量、引用、重载、布尔

// #include  // C语言的标准支持

#include  // C++标准支持  C++的与众不同

using namespace std; // 命名空间 C++ 的特性 （Java语言的内部类）

int main() {
    // C++语言面向对象 + 标准特性
    // C语言面向过程，函数+结构体
    // C++里面可以运行C语言，可以调用C语言，反之 就不行C语言无法运行C++
    // 小故事：谣言 C++--  在C语言上增加好的内容

    // C++里面可以运行C语言，可以调用C语言，反之 就不行C语言无法运行C++
    printf("降龙十八掌(C版)\n");

    // std::cout << "C++语言的学习" << std::endl;
    cout << "C++语言的学习" << endl; // 因为你前面引入了命名空间，省略std::

    // endl == \n  都是换行的含义一样

    // Kotlin也有操作符重载， Kotlin就是各个语言的精华所在

    // << 不是属性里面的运算，操作符重载，后面会讲
    cout << "擒龙功" << endl;

    cout << "铁头功\n"
         << "金刚腿\n"
         << "铁布衫\n";

    return 0;
}

真常量

#include 

// C++语言的常量，其实是真常量，C常量还是可以修改值
int main() {
    const int number = 100;

    // number = 200;

    // 我的编译器，编译不通过， 有的编译器，编译通过，但是运行报错（结论：就不能改）
    // int * numP = &number;

    // *numP = 10000;

    printf("%d\n", number);

    return 0;
}

引用（引用的赋值或者传递相当于指针取了个别名，不管如何操作这个别名，操作的还是这个指针）

#include 

using namespace std;

// 互换两个数

// 指针取地址 互换  C语言第一节课的内容
// 接收number1/number2的地址，取改地址的值，来完成的互换
void numberChange(int * number1, int * number2) {
    int temp = 0;
    temp = *number1;
    *number1 = *number2;
    *number2 = temp;
}

// C++提倡的引用
void numberChange2(int & number1, int & number2) {

    // 如果不采用引用，main numberChange2 内存地址是不一样的
    // 如果采用引用，main numberChange2 内存地址是一样的，为什么呢？
    cout << "numberChange2 " << "n1地址：" << &number1 << " , n2地址：" << &number2 <

常量引用

#include 
#include 

using namespace std;

// 代码的统一性
typedef struct {
    char name[20];
    int age;
}Student;

// 常量引用：Student不准你改 == const Student &
// 插入数据库，Student的信息给插入数据库
void insertStudent(const Student & student) {
    // 内鬼 卧底
    // strcpy(student.name, "李元霸"); 不能这样修改

    Student student2 = {"刘奋", 43};
    // student = student2; 不能这样修改

    // 只读的了，可以安心插入数据库了
    cout << student.name << "," << student.age << endl;
}

int main() {

    // 用户提交的Student数据
    Student student = {"张无忌", 30};
    insertStudent(student);

    return 0;
}

指针常量 常量指针 常量指针常量

#include 
#include 
#include 

using namespace std;

int main() {

    // *strcpy (char *__restrict, const char *__restrict);
    // strcpy()


    int number = 9;
    int number2 = 8;

    // 大道至简 一分钟搞定

    // 常量指针
    const int * numberP1 = &number;
    // *numberP1 = 100; // 报错，不允许去修改【常量指针】存放地址所对应的值
    // numberP1 = &number2; // OK，允许重新指向【常量指针】存放的地址

    //  指针常量
    int* const numberP2 = &number;
    *numberP2 = 100; // OK，允许去修改【指针常量】存放地址所对应的值
    // numberP2 = &number2; // 报错，不允许重新指向【指针常量】存放的地址

    // 常量指针常量
    const int * const numberP3 = &number;
    // *numberP3 = 100; // 报错，不允许去修改【常量指针常量】存放地址所对应的值
    // numberP3 = &number2; // 报错，不允许重新指向【常量指针常量】存放的地址

    return 0;
}

重载

// C++语言的函数重载 是支持的

#include 

using namespace std;

// Java构造函数  50个字段，我真正使用的，只有6个
// 建造者设计模式 去解决此问题

// int add(int number1, int number2) = number1 + number2; // 这个是KT写法

int add(int number1) {
    return number1;
}

int add(int number1, int number2) {
    return number1 + number2;
}

// C++重载 == Java重载
int add(int number1, int number2, int number3) {
    return number1 + number2 + number3;
}

// 函数重载 二义性
// 自己做实验
// 默认行参赋值，   // KT也有默认行参赋值   优先寻找默认行参赋值的函数， 跟顺序无关
int add(double n1 = 100, int n2 = 200, int n3 = 300, int n4 = 400, bool isOK = 0) {
    return 0;
}

// 后面：函数顺序的问题？

int main() {
    add(999);

    add(999, 777);

    add(100, 200, 888);

    return 0;
}

系统源码里面大量的写法 [特殊写法，意义何在]

#include 

using namespace std;

// 前期先抽象出现，我后面再升级
// 后面你可以扩展
void JNIMethod(double, double, int, int) {

}

// 上层日志
// 我前期的时候，没有考虑好，为了防止扩展功能，你必须传递一个int类型参数
// 0：服务器同步，   1：友萌服务器同步     2：服务器同步+友萌服务器同步
void uploadLogToEngine(char * logText, int mode) {
    // 普通上传日志

    // 半年过后，我再来补这个功能
    if (mode) {

    } else if (mode == 1) {

    }
}

int main(void) {
    // 前面一个月开发功能的时候
    uploadLogToEngine("xxxxx", 0); // 300出地方调用
    uploadLogToEngine("xxxxx", 2); // 600出地方调用
    uploadLogToEngine("xxxxx", 1); // 400出地方调用

    JNIMethod(9.0 ,9.9, 1, 2);

    return 0;

}

C++面向对象

#include "Student.h"

int main() {
    // 规范写法：要有 头文件.h .hpp   --   实现文件 .c  cpp

    std::cout << 1 << std::endl;


    // TODO  =======      下面是栈空间

    Student student1; // 栈区开辟空间的

    // 赋值
    student1.setAge(99);
    student1.setName("李连杰");

    cout << "name:" << student1.getName() << " ,age:" << student1.getAge() << endl;


    // TODO  =======      下面是堆空间

    Student * student2 = new Student(); // new/delete

    // 赋值
    student2->setAge(88);
    student2->setName("李元霸");

    cout << "name:" << student2->getName() << " ,age:" << student2->getAge() << endl;

    if (student2)
        delete student2; // 必须手动释放堆空间的对象student2
        student2 = NULL; // 指向NULL的地址区域
        // free(student2); // 不能这样写，不规范，会被鄙视的

    return 0;


    // 以后学习C++的时候，可能没有写头文件，是不规范的，只是为了讲课
    // 真实开发过程中，必须规范来：
    // 正规的流程：【xxx.so（C/Cpp的实现代码） 用户拿到xxx.so】， 头文件


} // main函数弹栈后，会释放栈成员 student1

bool 非零即true

#include 

using namespace std; // std 是系统的，必须这样叫

int main() {

    // bool  isOK = 1; // !0 就true
    // bool  isOK = -8891; // !0 就true
    // bool  isOK = 4359; // !0 就true
    bool  isOK = 0; // 0 就false

    // 只有两个类型： !0   0
    // 和前面的C一模一样

    if (isOK) {
        cout << "真" << endl;
    } else {
        cout << "假" << endl;
    }

    // ==========================
    bool isRun = true;
    isRun = false;
    cout << isRun << endl; // true==1,   false=0

    return 0;
}