C++ 如何重复利用一个内存地址块

 1 #include<iostream>
 2 using namespace std;
 3 const int size = 10;
 4 double buf[size] = {0};
 5
 6 int main(int argv ,char * args[]) {
 7
 8     double *p1,*p2;
 9      p1 = new double[size];
10      p2 = new (buf)double[size];
11      for (int i = 0; i < size; i++) {
12          p1[i]=p2[(i+2)%size]=i+2;
13          cout << "p1== " << &p1[i] << "    p1[i]=="<<p1[i]<<"   "<< endl;
14      }
15      cout << "---------------华丽丽的分割线-----------------------" << endl;
16      for (int i = 0; i < size; i++) {
17          cout << "p2== " << &p2[i] << "    p2[i]==" << p2[i] << "   " << endl;
18      }
19      cout << "---------------一大波内存袭来!-----------------------" << endl;
20      double *p3, *p4;
21      p3 = new double[size];
22      p4 = new (buf)double[size];
23      for (int i = 0; i < size; i++) {
24          p3[i] = p4[(i + 2) % size] = i + 2;
25          cout << "p3== " << &p3[i] << "    p3[i]==" << p3[i] << "   " << endl;
26      }
27      cout << "---------------华丽丽的分割线-----------------------" << endl;
28      for (int i = 0; i < size; i++) {
29          cout << "p4== " << &p4[i] << "    p4[i]==" << p4[i] << "   " << endl;
30      }
31      cout << "###################华丽丽的分割线########################" << endl;
32      //数组指针
33      double *p[] = {p1,p2,p3,p4};
34      for (int i = 0; i < 4; i++)
35          for (int j = 0; j < size; j++) {
36              cout << "p["<<i<<"]== " << &p[i][j] << "    p["<<i<<"]"<<"["<<j<<"]==" << p[i][j] << "   " << endl;
37          }
38
39      for (int i = 0; i < 4; i++) {
40           //释放new创建的内存
41          if (p[i]!=buf)  delete [] p[i] ;
42      }
43      cout << "内存释放之后" << endl;
44      for (int i = 0; i < size; i++) {
45
46          cout << "p1== " << &p1[i] << "    p1[i]==" << p1[i] << "   " << endl;
47      }
48      cin.get();
49     return 0;
50 }
 1 p1== 0038DC28    p1[i]==2
 2 p1== 0038DC30    p1[i]==3
 3 p1== 0038DC38    p1[i]==4
 4 p1== 0038DC40    p1[i]==5
 5 p1== 0038DC48    p1[i]==6
 6 p1== 0038DC50    p1[i]==7
 7 p1== 0038DC58    p1[i]==8
 8 p1== 0038DC60    p1[i]==9
 9 p1== 0038DC68    p1[i]==10
10 p1== 0038DC70    p1[i]==11
11 ---------------华丽丽的分割线-----------------------
12 p2== 0125C2D0    p2[i]==10
13 p2== 0125C2D8    p2[i]==11
14 p2== 0125C2E0    p2[i]==2
15 p2== 0125C2E8    p2[i]==3
16 p2== 0125C2F0    p2[i]==4
17 p2== 0125C2F8    p2[i]==5
18 p2== 0125C300    p2[i]==6
19 p2== 0125C308    p2[i]==7
20 p2== 0125C310    p2[i]==8
21 p2== 0125C318    p2[i]==9
22 ---------------一大波内存袭来!-----------------------
23 p3== 0038B1F8    p3[i]==2
24 p3== 0038B200    p3[i]==3
25 p3== 0038B208    p3[i]==4
26 p3== 0038B210    p3[i]==5
27 p3== 0038B218    p3[i]==6
28 p3== 0038B220    p3[i]==7
29 p3== 0038B228    p3[i]==8
30 p3== 0038B230    p3[i]==9
31 p3== 0038B238    p3[i]==10
32 p3== 0038B240    p3[i]==11
33 ---------------华丽丽的分割线-----------------------
34 p4== 0125C2D0    p4[i]==10
35 p4== 0125C2D8    p4[i]==11
36 p4== 0125C2E0    p4[i]==2
37 p4== 0125C2E8    p4[i]==3
38 p4== 0125C2F0    p4[i]==4
39 p4== 0125C2F8    p4[i]==5
40 p4== 0125C300    p4[i]==6
41 p4== 0125C308    p4[i]==7
42 p4== 0125C310    p4[i]==8
43 p4== 0125C318    p4[i]==9
44 ###################华丽丽的分割线########################
45 p[0]== 0038DC28    p[0][0]==2
46 p[0]== 0038DC30    p[0][1]==3
47 p[0]== 0038DC38    p[0][2]==4
48 p[0]== 0038DC40    p[0][3]==5
49 p[0]== 0038DC48    p[0][4]==6
50 p[0]== 0038DC50    p[0][5]==7
51 p[0]== 0038DC58    p[0][6]==8
52 p[0]== 0038DC60    p[0][7]==9
53 p[0]== 0038DC68    p[0][8]==10
54 p[0]== 0038DC70    p[0][9]==11
55 p[1]== 0125C2D0    p[1][0]==10
56 p[1]== 0125C2D8    p[1][1]==11
57 p[1]== 0125C2E0    p[1][2]==2
58 p[1]== 0125C2E8    p[1][3]==3
59 p[1]== 0125C2F0    p[1][4]==4
60 p[1]== 0125C2F8    p[1][5]==5
61 p[1]== 0125C300    p[1][6]==6
62 p[1]== 0125C308    p[1][7]==7
63 p[1]== 0125C310    p[1][8]==8
64 p[1]== 0125C318    p[1][9]==9
65 p[2]== 0038B1F8    p[2][0]==2
66 p[2]== 0038B200    p[2][1]==3
67 p[2]== 0038B208    p[2][2]==4
68 p[2]== 0038B210    p[2][3]==5
69 p[2]== 0038B218    p[2][4]==6
70 p[2]== 0038B220    p[2][5]==7
71 p[2]== 0038B228    p[2][6]==8
72 p[2]== 0038B230    p[2][7]==9
73 p[2]== 0038B238    p[2][8]==10
74 p[2]== 0038B240    p[2][9]==11
75 p[3]== 0125C2D0    p[3][0]==10
76 p[3]== 0125C2D8    p[3][1]==11
77 p[3]== 0125C2E0    p[3][2]==2
78 p[3]== 0125C2E8    p[3][3]==3
79 p[3]== 0125C2F0    p[3][4]==4
80 p[3]== 0125C2F8    p[3][5]==5
81 p[3]== 0125C300    p[3][6]==6
82 p[3]== 0125C308    p[3][7]==7
83 p[3]== 0125C310    p[3][8]==8
84 p[3]== 0125C318    p[3][9]==9
85 内存释放之后
86 p1== 0038DC28    p1[i]==-1.45682e+144
87 p1== 0038DC30    p1[i]==-1.45682e+144
88 p1== 0038DC38    p1[i]==-1.45682e+144
89 p1== 0038DC40    p1[i]==-1.45682e+144
90 p1== 0038DC48    p1[i]==-1.45682e+144
91 p1== 0038DC50    p1[i]==-1.45682e+144
92 p1== 0038DC58    p1[i]==-1.45682e+144
93 p1== 0038DC60    p1[i]==-1.45682e+144
94 p1== 0038DC68    p1[i]==-1.45682e+144
95 p1== 0038DC70    p1[i]==-1.45682e+144   

这样,可以对内存进行很好的利用,避免内存泄露。而导致系统运行越来越慢!

时间: 2024-10-17 08:43:33

C++ 如何重复利用一个内存地址块的相关文章

理解C指针: 一个内存地址对应着一个值

一个内存地址存着一个对应的值,这是比较容易理解的. 如果程序员必须清楚地知道某块内存存着什么内容和某个内容存在哪个内存地址里了,那他们的负担可想而知.    汇编语法对"一个内存地址存着一个对应的数",作了简单的"抽象":把内存地址用变量名代替了,对内存地址的取值和赋值方式不变.    c语言对此进行了进一步的抽象:变量 <==> (一个内存地址,对应的值)(这里忽略类型等信息). 把C语言中的基本类型(int,long,float等),指针,数组等还原

关于内存地址和内存空间的理解。

1.内存地址用4位16进制和8位16进制表示的区别.例如经常可以看到某些书籍上写的内存地址0x0001,在另外一些书籍上写的内存地址又变成了0x00000001.都是表示的编号为1的内存地址,为什么一个是4位16进制表示,另外一个又是用8位16进制表示呢? 首先,必须要知道内存地址只是一个编号,代表一个内存空间.那么这个空间是多大呢?原来在计算机中存储器的容量是以字节为基本单位的.也就是说一个内存地址代表一个字节(8bit)的存储空间. 例如经常说32位的操作系统最多支持4GB的内存空间,也就是

c语言中通过指针将数值赋值到制定内存地址

1.一种直观的方法 假设现在需要往内存0x12ff7c地址上存入一个整型数0x100.我们怎么才能做到呢? 我们知道可以通过一个指针向其指向的内存地址写入数据,那么这里的内存地址0x12ff7c其本质不就是一个指针嘛.所以我们可以用下面的方法: int *p = (int *)0x12ff7c; *p = 0x100; 需要注意的是将地址0x12ff7c赋值给指针变量p的时候必须强制转换. 1.1 为什么在此处,我们敢往0x12ff7c这个地址赋值呢? 至于这里为什么选择内存地址0x12ff7c

汇编语言学习第七章-更灵活的定位内存地址的方法

本博文系列参考自<<汇编语言>>第三版,作者:王爽 前面已经通过类似[0]和[bx]的方法进行了内存定位了.本章将涉及更多内存地址定位和编程的方法. 7.1 and 和 or 指令 (1) and指令,逻辑按位与指令 例如: mov al,01100011B and al,00111011B 执行后 al=00100011B and指令可以用来将某个数的位置为零. 比如我们要将al的第二位置为零,则: and al,11111101B 依次类推. (2) or指令,逻辑按位或指令

内存地址和内存空间

转自:http://www.cnblogs.com/VIPler/p/4282584.html 1. 内存地址用4位16进制和8位16进制表示的区别.例如经常可以看到某些书籍上写的内存地址0x0001,在另外一些书籍上写的内存地址又变成了0x00000001.都是表示的编号为1的内存地址,为什么一个是4位16进制表示,另外一个又是用8位16进制表示呢? 首先,必须要知道内存地址只是一个编号,代表一个内存空间.那么这个空间是多大呢?原来在计算机中存储器的容量是以字节为基本单位的.也就是说一个内存地

内存和内存地址

1.内存地址用4位16进制和8位16进制表示的区别.例如经常可以看到某些书籍上写的内存地址0x0001,在另外一些书籍上写的内存地址又变成了0x00000001.都是表示的编号为1的内存地址,为什么一个是4位16进制表示,另外一个又是用8位16进制表示呢? 首先,必须要知道内存地址只是一个编号,代表一个内存空间.那么这个空间是多大呢?原来在计算机中存储器的容量是以字节为基本单位的.也就是说一个内存地址代表一个字节(8bit)的存储空间. 例如经常说32位的操作系统最多支持4GB的内存空间,也就是

内存地址是什么

逻辑上,内存是一个有序字节组成的数组,每个字节有唯一的内存地址,那这个地址到底是啥. cpu通过数据,地址,控制总线完成与内存的交互.地址总线一共有32根,每一根的值是1或0.内存最基本的单位是字节,8个二进制. 内存地址是对每一个字节的映射.换句话说,是32位二进制数相对一个8位二进制数的映射.(数组是什么,是一个整数对某一个数组元素的映射) 内存地址是地址总线上所有位构成的一个值.用这个值可以操纵内存中唯一的一个字节. 如何快速有效的对字节寻址呢?最早最通用的cpu(80x86)中应用了一种

内存地址与内存空间

概览 基本概念 进入误区 误区诊断 总结 基本概念 什么是位? 什么是字节? 位表示的是二进制位,一般称为比特,即0或1,是计算机存储的最小单位: 字节是计算机中数据处理的基本单位: 计算机中以字节为单位存储和解 释信息,规定一个字节由八个二进制位构成,即1个字节等于8个比特. 1Byte=8bit 地址总线? (1)CPU是通过地址总线来指定存储单元的. (2)地址总线决定了cpu所能访问的最大内存空间的大小. (3)地址总线是地址线数量之和. 内存地址? 是一种用于软件及硬件等不同层级中的数

有两个CIDR地址块208.128/11和208.130.28/22。是否有那一个地址块包含了另一个地址?如果有,请指出,并说明理由。

208.128/11的前缀为:11010000 100: 208.130.28/22的前缀为:11010000 10000010000111,它的前11位于208.128/11的前缀是一致的, 所以208.128/11地址块包含了208.130.28/2这一地址块. 原文地址:https://www.cnblogs.com/wangjiaolong/p/12076610.html