关闭

四、新的关键字

121人阅读 评论(0) 收藏 举报
分类:

一、动态类型分配(c中用库函数实现,c++中用关键字)

(1).动态内存分配用new关键字
(2).删除用delete关键字

#include<stdio.h>
int main()
{
    int *p1 = new int;
    char *p = new char[10];
    *p1 = 5;
    p[0] = 'a';
    printf("%d\n",*p1);
    printf("%c\n",p[0]);
    delete p1;//一定要记得释放
    delete[] p;//注意释放的方法不一样
    getchar();
    return 0;
}

(3).new与malloc函数的区别:
new关键字是c++的一部分,malloc是由c库提供的函数
new 以具体类型为单位进行内存分配,malloc只能以字节为单位进行内存分配
new 在申请单个类型变量的时候可以进行初始化,malloc不具备内存初始化的特性

#include<stdio.h>
int main()
{
    char *p = new char('c');
    int *p1 = new int(3);
    printf("%c\n",*p);//打印字符c
    printf("%d",*p1);//打印3
    delete p;//最后要记得释放
    delete p1;
    getchar();
    return 0;
}

二、c++中的命名空间

(1).在C语言中只有一个全局作用域,所以的全局标识符共享一个作用域,标识符之间可能发生冲突
(2).c++中提出命名空间的概念:
命名空间将全局作用域分成不同的部分,不同命名空间中的标识符可以同名而不会发生冲突
命名空间可以互相嵌套
全局作用域也叫默认空间命名(c原来的全局作用域)
(3).c++命名空间的定义:
namespace name{}

(4).如何使用命名空间里面的东西?
使用整个命名空间: using namespace name;
使用命名空间中的变量:using name::variable;
使用默认命名空间的变量(即没有名字的命名空间): ::variable;

#include<iostream>
using namespace std;
namespace first
{
    namespace four
    {
        int i = 5;
        int b = 9;
    }

}
namespace second
{
    namespace third
    {
        int x=6;
        int y=7;
    }
}
int a = 2;
int main()
{

    using namespace first::four;
    using second::third::x;//注意使用某个变量时不需要namespace
    printf("%d\n", ::a);//使用默认命名空间
    printf("%d\n",i);//four 命名空间已经被打开,里面的东西都可以用
    printf("%d\n", b);//four 命名空间已经被打开,里面的东西都可以用
    printf("%d\n",x);
    //printf("%d\n", y);//会报错,因为y没有打开被使用
    getchar();
    return 0;
}

三、强制类型转换

1.c方式的强制类型转换:(Type)(expression)或Type(expression)两者无本质区别
c转换的问题:
(1).过于粗暴:任意类型的都可以转换,编译器难以判断
(2).难以定位:在源码中无法快速定位所有使用的强制类型转换的语句

2.c++将强制类型转换分成四种不同类型(static_cast、const_cast、dynamic_cast、reinterpret_cast。c++将这四个变成自己的关键字)
(1).static_cast:
a. 用于基本类型间的转换,但不能用于基本类型指针的转换(int to char)
b. 用于有继承关系类对象之间的转换和类指针之间的转换
c. static_cast是编译期进行转换的,无法在运行时检查类型,所以类型
之间的转换可能存在风险

#include<stdio.h>
int main()
{
    int i = 97;
    char c;
    int *p1 = &i;
    char *p2;
    c = static_cast<char>(i);
    //p2 = static_cast<char *>(p1);//报错,基本类型的指针无法转换
    printf("%c\n",c);
    getchar();
    return 0;
}

(2).const_cast:用于去除变量的const属性,用于指针或者引用

#include<stdio.h>
int main()
{
    const int& j = 2;//之前在const引用那里讲过,这里为为常量分配了空间,只读变量
    int& k = const_cast<int&>(j);//去掉只读变量的特性
    k = 3;
    printf("%d\n",j);//打印的值都是3
    printf("%d\n",k);
    getchar();
    return 0;
}
#include<stdio.h>
int main()
{
    const int j = 2;
    int& k = const_cast<int&>(j);//去掉常量的特性
    k = 3;
    printf("%d\n",j);//打印的值都是2
    printf("%d\n",k);//打印的值是3
    //原因:j是常量,在符号表里,即使为它分配了地址,也不用里面的值
    getchar();
    return 0;
}

(3).reinterpret_cast:
用于指针间的强制类型转换
用于整数和指针类型的强制类型转换

#include<stdio.h>
int main()
{
    int j = 97;
    int *p1 = &j;
    char *p2;
    p2 = reinterpret_cast<char*>(p1);//用于指针类型的转换
    printf("%c\n",*p2);
    getchar();
    return 0;
}

(4).dynamic_cast:
主要用于类层次间的转换,还可以用于类之间的交叉转换
具有类型检查功能,比static_cast安全

0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:5358次
    • 积分:375
    • 等级:
    • 排名:千里之外
    • 原创:33篇
    • 转载:0篇
    • 译文:0篇
    • 评论:1条
    文章分类
    文章存档
    最新评论