|
- UID
- 852665
|
本节知识点：1.关键字new与delete： a.c++中通过new关键字进行动态内存分配，new是一种基于类型进行的内存分配，同时c++使用delete进行内存释放
单个变量内存申请与释放：Type* p = new Type; delete p;
一段内存空间的申请与释放：Type* p = new Type [N]; delete [] p;
示例代码如下：
[cpp] view plaincopy 
- #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);
- }
- 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不具备内存初始化的特性，代码如下：
[cpp] view plaincopy
- #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.命名空间的语法：
定义命名空间(要在函数外面定义)：
[cpp] view plaincopy
- 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变量使用。代码如下：
[cpp] view plaincopy
- #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是编译期进行的转换，无法在运行时检测类型，所以类类型之间的转换可能存在风险。代码如下：
[cpp] view plaincopy
- #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只读属性。代码如下：[cpp] view plaincopy
- #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)
引用间的强制类型转换(代码如下)：
[cpp] view plaincopy
- #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类型用法，代码如下：
[cpp] view plaincopy
- #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更安全。这个问题等对类有了理解再回来补充。
|
|
