c++学习笔记(4.c++中新的关键字)

本节知识点：

1.关键字new与delete：

   a.c++中通过new关键字进行动态内存分配，new是一种基于类型进行的内存分配，同时c++使用delete进行内存释放
      单个变量内存申请与释放：Type* p = new Type;           delete   p;
      一段内存空间的申请与释放：Type* p = new Type
;           delete  []   p;     
      示例代码如下：

#include <stdio.h>
#include <malloc.h>
int main()
{
/*使用new申请单个变量*/
double* p = new double;
*p = 7.2;
printf("%f\n",*p);
delete p;

int *p1 = (int*)malloc(sizeof(int)*10);
for(int i = 0; i < 10; i++)
{
*(p1+i) = i;
}
for(int i = 0; i < 10; i++)
{
printf("%d\n",p1[i]);
}
free(p1);

/*使用new申请一段连续的内存空间*/
//new出来的这个空间看着像数组 但它跟数组有本质区别  这是在堆区的
int *p2 = new int[10];
for(int i = 10; i > 0; i--)
{
p2[10-i] = i;
}
for(int i = 0; i < 10; i++)
{
printf("%d\n",*(p2+i));
}
delete [] p2;
return 0;
}

   b.new关键字与malloc函数的区别：
      第一：new关键字是c++的一部分，而malloc是由c库提供的函数
      第二：new是以具体类型为单位进行内存分配，malloc只能以字节为单位进行内存分配
      第三：new在申请单个类型变量时可进行初始化，malloc不具备内存初始化的特性，代码如下：

#include <stdio.h>
int main()
{
int* p = new int(6);
printf("%d\n",*p);

double* fp = new double(7.2);
printf("%f\n",*fp);

char* cp = new char('d');
printf("%c\n",*cp);

return 0;
}

2.c++中的命名空间：

    a.命名空间产生的原因：在c语言中只有一个全局作用区，所有的全局标识符(包括全局变量、函数)共享同一个全局作用区。尽管有static关键字的限制，但是在工程中依然存在接口函数名之间，或与库函数名冲突的现象。所以c++中提出了命名空间的概念，命名空间将全局作用区分成了若干的命名空间和无名空间(即默认空间，也就是兼容c语言的全局作用区的空间)。
    b.命名空间的有效作用域：在c语言中没有命名空间的概念，导致所有在全局作用区的全局标识符的作用域都是，从这个变量或者函数定义声明开始一直有效到程序结束(从始至终贯穿着整个程序，所有很容易就冲突了)。而c++中有了命名空间的概念后，一旦在一个函数中使用using namespace name1;    using
name1::a;这样的语句的时候，name1这个命名空间的作用域和name1中a变量的作用域，就是从using命令开始到这个函数结束(也就是说可以通过命名空间来控制全局变量的作用域了)。如果是在一个命名空间name2中使用using命令的话，那name1和a的作用域就属于name2了(即与name2属于相同作用域)。如果在默认命名空间(无名空间)中使用using命令，name1和a的作用域就变化与c语言一样的那个全局作用区了。如果使用name1::a这样方法直接去控制变量的话，那作用域就是使用瞬间。
     c.命名空间的语法：
        定义命名空间(要在函数外面定义)：

namespace name2   //这个是命名空间的嵌套
{
int c = 2;
int f = 5;
namespace name3
{
int d = 3;
int e = 4;
}
}

          使用命名空间(有三种方式)：
           第一：using spacename name1;  开启name1这个命名空间，可以使用这个命名空间中的所有变量了。
           第二：using name1::a;   可以使用name1命名空间中的a变量了。
           第三：name1::a = 10;   直接使用name1命名空间的a变量
           第四：::a = 10; 或者  a = 10;    直接使用默认命名空间中的变量
       d.使用命名空间要注意：
           第一：命名空间是可以相互嵌套的，且有一个嵌套顺序的问题，不同嵌套顺序的命名空间，即使名称相同，也是不同的命名空间。因为using的时候，是有顺序的。
           第二：相同名称的命名空间，在using的时候，两个命名空间都会被打开。只要相同名称的命名空间中没有同名变量就可以！否则在使用这个变量的时候，就会出现二义性，编译会出问题。
           第三：不同命名空间中，标识符可以同名而不会发生冲突！因为在使用的时候，不一定会同时using这两个命名空间，所以不一定会产生二义性！但是如果同时打开这两个命名空间，还去使用了这个同名变量，编译也会出错，因为产生二义性！但是当using spacename name1;(name1中有变量a)  并且using name2::a的时候，再使用a变量的时候就没有二义性了，编译器默认选择name2中的a变量使用。代码如下：

#include<stdio.h>

namespace name1
{
int a = 9;
namespace name1
{
int a = 10;
}
}
namespace name2
{
int p = 19;
int a = 0;
}

int  main()
{
using namespace name1;
using name2::a;
printf("%d\n",a);
return 0;
}

3.c++中的强制类型转换：

    a.c语言中的强制类型转换：有两种方式，(Type) name     和   Type (name)  注意第二种方式不是很常用。

    b.c语言中强制类型转换存在的问题：
       第一：过于粗暴，任何类型之间都可以进行转换，编译器很难判断其正确性。
       第二：难于定位，在源码中无法快速定位所有使用强制类型转换的语句。
       补充：在程序设计理论中强制类型转换不被推荐，与goto语句一样，应该进行避免，因为在程序设计过程中，定义变量就应该清楚变量的使用环境，直接定义成有效的类型，避免强制类型转换。还有就是现代的软件产品里面有三个问题是bug的源泉：有运算符的优先级问题、多线程编程中各个线程的交互、强制类型转换。
    c.c++中将强制类型转换分成四个类型：
       static_cast类型：用于基本类型间的转换，但不能用于指针类型间的转换。用于有继承关系对象之间的转换和类指针之间的转换。但是static_cast是编译期进行的转换，无法在运行时检测类型，所以类类型之间的转换可能存在风险。代码如下：

#include <stdio.h>
int main()
{
int a = 99;
double b = static_cast<double>(a);
printf("%f\n",b);

printf("%c\n",static_cast<char>(b));
getchar();
return 0;
}

        const_cast类型：用于去除变量的const属性，注意，它只能去除const int* p或者const int& p这两种类型中的const属性。比如int* const p类型中的const属性是去不掉的，其实不管用什么手段这个const的属性都是去不掉的，int* const p =
&a;  p一旦指向就不能再改变指向，这其实就是引用的实质！！！
        const_cast类型有三个常用环境：第一，去除const int &j;的const只读属性、第二，去除const int * j;的const只读属性、第三，去除const int j;的const只读属性。代码如下：

#include <stdio.h>
int main()
{
/*const int &j  去除const属性*/
const int& j = 4;
const_cast<int&>(j) = 6;  //其实实际上j就是一个只读变量 利用指针也可以改变j的值的
//	*(int*)(&j) = 6;  //这步的强制类型转换与上面那句代码等效
printf("j is %d\n",j);
int& i = const_cast<int&>(j);
i = 12;
printf("j is %d\n",i);

/*const int* p 去除const属性*/
int a = 1;
const int* p = &a;
*const_cast<int*>(p) = 2;
// 	*(int* )p = 2; //与上面代码等效的强制类型转换
printf("*p is %d\n",*p);

/*const int l = 6*/
const int l = 16;
const_cast<int&>(l) = 17;
//    (int&)l = 17;  //与上面语句等效的强制类型转换
//    *const_cast<int*>(&l) = 17;
//	*(int*)&l = 17;
printf("l is %d\n",l);
return 0;
}

对于上面代码有两点要说明：
第一：const_cast其实只读const指针和const引用起作用了，对const常量没有起作用，因为const常量是保存在符号表中的。
第二：对于引用的强制类型转换，int a = 10;  (char)a这是将a变量中的值强制类型转换成char类型，切记此时(char)a不是变量不能当做左值使用。但是(char&)a是将a强制类型转换成char类型的引用，其实是一个变量可以当做左值使用！对于const_cast<int&>(l) = 17; 来说l常量是存放在符号表中的，而const_cast<int&>(l)其实是个有内存空间的变量，其实相当于对l取地址的时候，编译器分配了一个内存空间，这个空间不是用来存放l常量的，而是强制类型转换后这个引用的内存空间，所以说这个17就存放在这个引用的内存空间了！！！
           reinterpret_cast类型：用于指针类型间的强制类型转换，用于整数和指针间的强制类型转换，还用于引用间的强制类型转换。(注：此处指针引用的强制类型转换都是没有const属性去除过程的，否则优先使用const_cast)

           引用间的强制类型转换(代码如下)：

#include <stdio.h>
int main()
{
int a = 10;
int &b = a;
char &c = reinterpret_cast<char&>(b);
printf("%d\n",reinterpret_cast<char&>(b));
a = 129;
printf("a is %d\n",a);
printf("b is %d\n",b);
printf("c is %d\n",c);
return 0;
}

              我们仔细说说代码中c引用与b引用的关系，不可否定的是abc三个变量，有其中任何一个变量改变了，都会对另外的两个起到改变的作用！a与b仅仅是名字不同的问题(其余完全相同)，但是c引用是与b引用变成char类型引用变量后完全相同的。
               reinterpret_cast类型用法，代码如下：

#include <stdio.h>
int main()
{
int a = 10;
*reinterpret_cast<unsigned int*>(&a) = 12;
printf("a is %d\n",a);
int* b = &a;
char* c = reinterpret_cast<char*>(b);
*c = 14;
printf("a is %d\n",*c);
return 0;
}

               reinterpret_cast是直接从二进制位进行复制，是一种极其不安全的转换。
       dynamic_cast类型：主要用于类层次间的转换，还可以用于类之间的交叉转换。dymanic_cast具有类型检查的功能，比static_cast更安全。这个问题等对类有了理解再回来补充。