C++--第5课 - 新的关键字

第5课 - 新的关键字

1. 动态内存分配

C++中通过new关键字进行动态内存申请，C++中的动态内存申请是基于类型进行的，delete关键字用于内存释放。

变量申请：

Type* pointer = new Type;

//......

delete pointer;

数组申请：

Type* pointer = new Type[N];

//......

delete[N] pointer;

程序：C++中的动态内存分配

#include <stdio.h>

int main()

{

    int* p = new int; 

    *p = 5;

    *p = *p + 10; 

    printf("p = %p\n", p);

    printf("*p = %d\n", *p); 

    delete p; 

    p = new int[10];  

    for(int i=0; i<10; i++)

    {

        p[i] = i + 1;

       

        printf("p[%d] = %d\n", i, p[i]);

    }   

    delete[] p;   

    printf("Press any key to continue...");

    getchar();

    return 0;

}

l  new关键字和malloc函数的区别

new关键字是C++的一部分，malloc是由C库提供的函数。new以集体类型为单位进行内存的分配，malloc只能以字节为单位进行内存分配。new在申请单个类型变量时可以进行初始化，malloc不具备内存初始化的特性。

 

程序：new关键字的初始化

#include <stdio.h>

int main()

{

    int* pi = new int(1);

    float* pf = new float(2.0f);

    char* pc = new char('c');  

    printf("*pi = %d\n", *pi);

    printf("*pf = %f\n", *pf);

    printf("*pc = %c\n", *pc);  

    delete pi;

    delete pf;

    delete pc;   

    printf("Press any key to continue...");

    getchar();

    return 0;

}

 

2. C++中的命名空间

在C语言中只有一个全局作用域，C语言中所有的全局标示符共享同一个作用域，表示符之间可能发生冲突。

C++中提出了命名空间的概念，命名空间将全局作用域分成不同的部分，不同命名空间中的标示符可以同名而不会发生冲突。命名空间可以相互嵌套，全局作用域也叫默认命名空间。

程序：C++命名空间的定义 

#include <stdio.h>

namespace First

{

    int i = 0;

}

namespace Second

{

    int i = 1; 

    namespace Internal

    {

        struct P

        {

            int x;

            int y;

        };

    }

}

int main()

{

    printf("Press any key to continue...");

    getchar();

    return 0;

}

l  C++命名空间的使用：

使用整个命名空间：using namespace name;

使用命名空间中的变量：using nama::variable;

使用默认命名空间中的变量：::variable

默认情况下可以直接使用默认命名空间中的所有标识符。

程序：C++命名空间的使用 

#include <stdio.h>

namespace First

{

    int i = 0;

}

namespace Second

{

    int i = 1;  

    namespace Internal

    {

        struct P

        {

            int x;

            int y;

        };

    }

}

int main()

{

    using namespace First;

    using Second::Internal::P;  

    printf("i = %d\n", i);

    printf("i = %d\n", Second::i);  

    P p = {2, 3}; 

    printf("p.x = %d\n", p.x);

    printf("p.y = %d\n", p.y);   

    printf("Press any key to continue...");

    getchar();

    return 0;

}

 

3. 强制类型转换

（1）C方式的强制类型转换(Type)(Expression) or Type(Expresssion)

#include <stdio.h>

typedef void(PF)(int);

struct Point

{

    int x;

    int y;

};

int main()

{

    int v = 0x12345;

    PF* pf = (PF*)v;

    char c = char(v); 

    pf(v);  

    Point* p = (Point*)v;   

    printf("p->x = %d\n", p->x);

    printf("p->y = %d\n", p->y);   

    printf("Press any key to continue...");

    getchar();

    return 0;

}

C方式强制类型转换存在的问题：

过于粗暴：任意的类型之间都可以进行转换，编译器很难判断正确性；难于定位：在源码中无法快速定位所有使用强制类型转换的语句。

在程序设计理论中强制类型转换不是被推荐的，与goto语句一样，应该尽量避免。

 

（2）C++中的强制类型转换

有四种类型：

static_cast

const_cast

dynamic_cast

reinterpret_cast

用法：xxx_cast<Type>(Expression)

l  static_cast强制类型转换

用于基本类型间的转换，但是不能用于基本类型指针之间的转换；用于有继承关系类对象之间的转换和类型指针之间的转换。static_cast是编译器进行转换的，无法在运行时检测类型，所以类型转换之间可能存在风险。

#include <stdio.h>

int main()

{

    int i = 0x12345;

    char c = 'c';

    int* pi = &i;

    char* pc = &c;

   

    c = static_cast<char>(i);

    pc = static_cast<char*>(pi);

   

    printf("Press any key to continue...");

    getchar();

    return 0;

}

l  const_cast

用于除去变量的const属性

#include <stdio.h>

int main()

{

    const int& j = 1;

    int& k = const_cast<int&>(j);

    const int x = 2;

    int& y = const_cast<int&>(x);   

    k = 5;

    printf("k = %d\n", k);

    printf("j = %d\n", j); 

    y = 8;  

    printf("x = %d\n", x);

    printf("y = %d\n", y);

    printf("&x = %p\n", &x);

    printf("&y = %p\n", &y);   

    printf("Press any key to continue...");

    getchar();

    return 0;

}

 

l  reinterpret_cast

用于指针类型间的强制转换，用于整数和指针类型之间的强制转换。reinterpret_cast直接从二进制位进行复制，是一种极其不安全的转换。

#include <stdio.h>

 

int main()

{

    int i = 0;

    char c = 'c';

    int* pi = &i;

    char* pc = &c;

   

    pc = reinterpret_cast<char*>(pi);

    pi = reinterpret_cast<int*>(pc);

   

    c = reinterpret_cast<char>(i); // Oops!

   

    printf("Press any key to continue...");

    getchar();

    return 0;

}

 

l  dynamic_cast

主要用于层次之间的转换，还可以用于类之间的转换；dynamic_cast具有类型检查的功能，比static_cast更安全。

 

小结：

C++中内置了动态内存分配的专用关键字，其中的动态内存分配是基于类型进行的。

C++中命名空间的概念用于解决名称冲突问题，C++细化了C语言中强制类型转换的方式。

C++不推荐在程序中使用强制类型转换，C++建议在强制类型转换的时候考虑一下究竟希望什么样的转换。

转载于:https://www.cnblogs.com/free-1122/p/11336169.html