C++学习：第三章C++语言基础 - （二）类型转换、常量、指针、new、delete、函数

1. C++中对常量访问的优化

C++中访问常量并不是每次都去内存中读取，只是读取一次，然后调用该值。C++中考虑常量是不会修改的，因此不用每次都去内存中读取。

如果我们强制修改了常量的值，再次输出时是没有修改之前的值，修改之后的值需访问内存才能得到。

#include <stdio.h>

int main(){

    const int n = 100;
    int m = 200;
    volatile const int s = 300;

    int* p = (int*)&n;
    int* q = &m;
    int* r = (int*)&s;

    *p = 666;
    *q = 777;
    *r = 888;

    /*
      下面输出100, 777, 888
      1. 比较了const的用法，其修饰的值无法修改，只能强制。
      2. 输出结果100， 777.这是C++中优化的结果，因为const修饰的值相当于常量，
        他只是去内存中取值一次，以后每次使用都调取上次的值，而在c语言中咋不是这样。
        C语言中每次都是去内存中取值，因此在C中的结果是 666 777；
      3. volatile关键字要求每次都是去内存中取数据，因此输出结果是 888
    */
    printf("%d, %d, %d \n", n, m, s);

    getchar();
    return 0;
}

2. C++ 中专门做类型转换的关键字

/   转载内容    //

dynamic_cast
1.dynamic_cast是在运行时检查的，用于在集成体系中进行安全的向下转换downcast(当然也可以向上转换，但没必要，因为可以用虚函数实现)

   即：基类指针/引用 -> 派生类指针/引用

   如果源和目标没有继承/被继承关系，编译器会报错！
2.dynamic_cast是4个转换中唯一的RTTI操作符，提供运行时类型检查。
3.dynamic_cast不是强制转换，而是带有某种”咨询“性质的，如果不能转换，返回NULL。这是强制转换做不到的。

4.源类中必须要有虚函数，保证多态，才能使用dynamic_cast<source>(expression)

static_cast

用法：static_cast < type-id > ( expression )

该运算符把expression转换为type-id类型，在编译时使用类型信息执行转换，在转换执行必要的检测（指针越界，类型检查），其操作数相对是安全的。

但没有运行时类型检查来保证转换的安全性。

reinterpret_cast

仅仅是复制n1的比特位到d_r, 没有进行必要的分析.interpret_cast是为了映射到一个完全不同类型\
的意思，这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄\
玄虚和其他目的，这是所有映射中最危险的。(这句话是C++编程思想中的原话

const_cast

去除const常量属性，使其可以修改

and

volatile属性的转换  易变类型<->不同类型.

https://www.cnblogs.com/luntai/p/5879026.html

///

static_cast：合理的转换，数值类型的转换、有一方是void*的指针类型转换。

const_cast：把常量转成变量，用于临时去掉const限制，只是在该转换语句本身起作用。

reinterpret_cast：任意两种指针之间、指针和数值之间的类型转换

dynamic_cast：用于父子类之间的转换。

#include <iostream>
//在c语言中的标准库在c++中都有对应的，就是去掉.h，同时在前面加个c
#include <cstdlib>

int main(){

    // static_cast
    int n = static_cast<int>(1.23);
    int* p = static_cast<int*>(calloc(sizeof(int), 10));

    /*
      const_cast
      1. 这里注意下，如果 const int k = n; 这样写，下面每次的结果是不一样的
      2. 如果 const int k = 0(或者其他常量); 这样写，下面每次的结果是一样的，都是0.
      3. 这是因为 C++ 的优化，虽然读取到的结果一样，但内存的数据实际上是修改了的
        因为优化的原因，常量直接读取值，不去内存访问，所以输出的还是0。
    */
    const int k = n;
    std::cout << k << std::endl;
    const_cast<int&>(k) = 678;
    std::cout << k << std::endl;
    const_cast<int&>(k) = 789;
    std::cout << k << std::endl;

    //reinterpret_cast
    float f = 1.2345;
    p = reinterpret_cast<int*>(&f);//是乱码
    n = int(1.23);// n = 1
    n = int();//n = 0

    getchar();
    return 0;
}

3. new 与 delete

new(类型) = (类型*)malloc(sizeof(类型));

delete  释放的是指针指向的空间，但是并没有释放指针，因此在delete之后会紧接着一个n = NULL;

#include <iostream>
#include <cstdlib>

using namespace std;
int main(){

    int* p = static_cast<int*>(malloc(sizeof(int)));//C
    int* q = new int;
    int* r = new int(123);

    int n = 9999;
    int* a = new int[n];//注意，这里可以是变量

    delete r;r = NULL;
    delete q;q = NULL;

    //[]表示是释放一片空间，该指针并没有释放，如果需要释放须置为NULL
    delete[] a;
    a = NULL;

    getchar();
    return 0;
}

4. 结构变量.*成员指针，结构指针->*成员指针

#include <iostream>
using namespace std;

struct date{
    int year;
    int mouth;
    int day;
}

void test(date* D){
    cout << D[0].month << "   " << 0 << endl ;
};

int main(){

    date a[5] = {{2010,8,16},
                {2010,7,16},
                {2016,4,16},
                {2010,8,19},
                {2010,10,16}};

    date d = {2018,4,6};
    date* pd = &d;
    pd->day;
    test(a);
    test(&d);

    //第一个成员的地址和结构体的地址是一样的，后面依据大小后延
    cout << &d << "   " << &d.year <<  "   " << &d.month <<  "   " << &d.day << endl;

     /*
        老师演示C++中无法获取函数和成员变量的地址问题，还有::取地址的写法
        但是我这里没有复现，写个老师的演示代码
        cout << &main << endl;//老师演示报错：总是显示4为true
        union{
            int n;
            int date::*mp;
        }

        mp = &date::day;
        cout << n << endl;
        cout << d.*mp << endl;
        mp = &date::year;
        cout << d.*mp << endl;
        //老师说的：结构变量.*成员指针，结构指针->*成员指针，我都没复现
    */

    getchar();
    return 0;
}

5. 用于新老函数兼容的哑元

#include <iostream>
using namespace std;

void f1(){cout << "dasda" << endl; }//等同于 void 无法传参
void f2(void){return f1(); }//返回函数
void f3(double){cout << "wjnweiu" << endl; }//有类型无名子：哑元，用于新老函数兼容

int main(){

    getchar();
    return 0;
}