【C/C++学院】0828-数组与指针/内存分配/数据结构数组接口与封装
【送给在路上的程序猿】
对于一个开发人员而言,可以胜任系统中随意一个模块的开发是其核心价值的体现。
对于一个架构师而言,掌握各种语言的优势并能够运用到系统中。由此简化系统的开发,是其架构生涯的第一步。
对于一个开发团队而言,能在短期内开发出用户惬意的软件系统是起核心竞争力的体现。
每个程序猿都不能固步自封,要多接触新的行业,新的技术领域,突破自我。
数组与指针
#include<stdio.h>
#include<stdlib.h> void main1()
{
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (int *p = a; p < a + 10; p++)//指针类型决定占4个字节
{
printf("\n%p,%d", p, *p);
} getchar();
} void main2()
{
//轮询数组的时候。用指针轮询。指针能够指向某个元素的大小
//指针数组,管理地址,依照顺序运行指令
char *str[5] = { "calc", "notepad", "tasklist", "pause", "mspaint" };
for (char **pp = str; pp < str + 5; pp++)//
{
system(*pp);
}
} void main3()
{
char str[5][10] = { "calc", "notepad", "tasklist", "pause", "mspaint" };
printf("%p", str);
//p[1],p[2],p[3]
//类型不一样
for (char(*p)[10] = str; p < str + 5; p++)
{
printf("\n %p,%s", p, p);//打印地址 字符串
system((char *)p);
} //char **pp = str;
//for (char **pp = str; pp < str + 5; pp++)//
//{
// system(*pp);
//}
system("pause");
} void main4()
{
char str[5][10] = { "calc", "notepad", "tasklist", "pause", "mspaint" };
printf("%p,%p,%p", str, &str, *str);
//指针地址的一样,可是类型不一样
//str代表行地址。&str代表整个数组的地址,*str就是第一个字符的地址 printf("\n%d,%d,%d", sizeof(*str), sizeof(*(&str)), sizeof(*(*str)));
////求指针指向内容占多大
//int num = 10;
//int *p1=#
//double db = 10.9;
//double * p2 = &db;
//printf("%d,%d", sizeof(p1), sizeof(p2));
//printf("\n%d,%d", sizeof(*p1), sizeof(*p2));
system("pause");
} void main5()
{
int a[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
printf("%p\n", a);
//int *p1 = &a[0][0];
//int *p2 = p1 + 4;
//printf("%d", *p2);
//int *p3 = p2 - 3;
//printf("\n%d", *p3);
//printf("\n%d", p2 - p3);
////C语言运算规则,加法加上元素的大小×加上的数
////减法就是减去元素的大小×减去的数
////int *p=0x300500 p+2*(sizeof(int))=0x300508
////char *p1=0x300500 p1+2*(sizeof(char))=0x300502
for (int *p = &a[0][0]; p < &a[0][0] + 12; p++)
{
if ((p - &a[0][0])%4 == 0)
{
printf("\n");
}
printf("%5d", *p);
}
printf("\n\n\n");
int (*px)[4] = a;//a是一个常量的行指针,a的类型与px等价的
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
//printf("%5d", a[i][j]);
//printf("%5d", px[i][j]);
//printf("%5d", *(px[i] + j));
printf("%5d", *(*(px + i) + j));
}
printf("\n");
} getchar();
}
数组与指针2
#include<stdio.h>
#include<stdlib.h> int searchmax(int a[3][4])//一维数组没有副本机制,二维数组也没有,数组作为參数都是传递地址
{ //printf("\nsearch=%d", sizeof(a));//
//int b[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2 };
//printf("\nsaerch b=%d", sizeof(b));
int max;//存储最大的值
max = a[0][0];
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
if (a[i][j]>max)//比較大小
{
max = a[i][j];//接受最大的地址
}
}
}
return max;
} int searchmaxA(int (*p)[4])//退化为一个指向有四个元素的数组的哦指针
{
//printf("\nsearch=%d", sizeof(a));//
//int b[3][4] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 1, 2 };
//printf("\nsaerch b=%d", sizeof(b));
int max;//存储最大的值
max = p[0][0];
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
if (p[i][j]>max)//比較大小
{
max = p[i][j];//接受最大的地址
}
}
}
return max;
} int searchmin(int(*p)[4])
{
//int min = p[0][0];//假定第一个是最小的
int min = *(*(p+0)+0);//第一个元素的大小 for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
//if (p[i][j]<min)//比較大小
//{
// min= p[i][j];//求出最小的数
//}
if (*(*(p + i) + j) < min)
{
min = *(*(p + i) + j);
} }
} return min;
} void main4()
{
int a[3][4] = { 1, 2, 3, 4, 5, 16, -7, 8, 9, 10, 1, 2 };
printf("\nmain=%d", sizeof(a));//
//printf("\n%d",searchA(a));//退化为一个指针
printf("\n%d", searchmin(a)); system("pause");
}
#include<stdio.h>
#include<stdlib.h>
#include<Windows.h> struct pos
{
int x;
int y;
}; //struct pos pos1[8] = { { 100, 200 },
//{ 100, 0 },
//{ 200, 400 } ,
//{300,400},
//{390,600},
//{ 190, 900 },
//{ 990, 100 },
//{ 1390, 600 }
//};
struct pos pos1[8][2] = { { { 100, 200 }, { 1000, 900 } },
{ { 200, 0 }, { 900, 800 } },
{ { 0, 0 }, { 800, 1300 } },
{ { 1500, 200 }, {600, 900 } },
{ { 800, 700 }, { 700, 800 } },
{ { 300, 100 }, { 600, 700 } },
{ { 900, 800 }, { 700, 700 } },
{ { 100, 200 }, { 800, 800 } },
}; void mainx()
{
HWND *win = FindWindowA("Notepad", "无标题 - 记事本");
if (win == NULL)
{
return;
}
SetWindowPos(win, NULL, 0, 0, 100, 300, 1);
for (int i = 0; i < 8; i++)
{
//设置窗体位置大小
SetWindowPos(win, NULL, pos1[i][0].x, pos1[i][0].y, pos1[i][1].x, pos1[i][1].y, 1);
Sleep(3000);
} system("pause");
}
三维数组
#include<stdio.h>
#include<stdlib.h>
//int a [10] int *p
//int a[10][9] int (*p)[9]
//int a[8] [9][10] int (*p)[9][10] void print3(int a[3][4][5])
{
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 5; k++)
{
printf("%4d", a[i][j][k]);
}
printf("\n");
}
printf("\n\n\n");
}
} void print3A(int (*p)[4][5])//指针的方式
{
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 4; j++)
{
for (int k = 0; k < 5; k++)
{
//printf("%4d", p[i][j][k]);
//指针訪问三维数组
printf("%4d", *(*(*(p + i) + j) + k)); }
printf("\n");
}
printf("\n\n\n");
}
} void main()
{
int a[3][4][5];
int num = 0;
printf("%d\n", sizeof(a));
//线性初始化
for (int *p = &a[0][0][0]; p < &a[0][0][0] + 60; p++)
{
*p = num;
num++;
}
//int(*px)[4][5] = a;//等价关系
print3A(a);
getchar();
}
内存分配
#include<stdio.h>
#include<stdlib.h> void main1()
{
int a[1024 * 1024];//栈溢出
int num = 100;
//int a[num];VC数组必须常量,GCC能够是变量
}
//添加。删除。查询,改动
int a[10];
int length=10; void main2()
{
for (int i = 0; i < length; i++)
{
printf("%d\n", a[i] = i);//初始化数组并打印
} int num = 3;
if (a[length - 1] == num)//判定最后一个
{
length -= 1;//长度递减
}
else
{
for (int i = 0; i < length - 1; i++) //遍历数组
{
if (num == a[i])//找到
{ for (int j = i; j < length-1; j++)//删除
{
a[j] = a[j + 1];//从后往前移动
}
length = length - 1;//长度-1
break;
}
} }
for (int i = 0; i < length; i++)
{
printf("%d\n", a[i] );//数组并打印
}
system("pause");
} void main3()
{
int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
//写C程序的时候,务必保证绝对不出错误。偶尔不报错
a[10] = 11;
a[11] = 12;
a[102345] = 123; getchar();
} void main()
{
int *p1 = (int*)malloc(sizeof(int)* 10);//仅仅管分配,不初始化
int *p2 = (int *)calloc(10,sizeof(int));//calloc会进行内存清零
printf("%p,%p", p1, p2); for (int i = 0; i < 10; i++)
{
p1[i] = i;
p2[i] = i;
}
getchar();
}
数据结构数组接口与封装
#include<stdio.h>
#include<stdlib.h> void main1()
{
int *p =(int *) calloc(10, sizeof(int));//分配内存
printf("%p\n", p);//输出地址 for (int i = 0; i < 10; i++)
{
*(p + i) = i;//*(p+i)等价于p[i]
} int *pnew = (int *)realloc(p, 100000);//变长
//realloc.第一种情况,后面的内存没人用,就直接拓展变长
//另外一种情况,后面的内存有人用,先分配新的长度,拷贝原来的内存,释放的原来的内存
printf("%p", pnew); for (int i = 10; i < 25000; i++)
{
*(pnew + i) = i;
} system("pause");
}
动态数组
#include<stdio.h>
#include<stdlib.h> struct data
{
int *p;//指针保存数组的起始点
int length;//保存数组的长度
int stat;//0代表无序。1代表有序从小到大。2有序从大到小
int reallength;//实际分配的内存长度
}; struct findres
{
int **pp;
int n;
};
//添加,删除,查找。改动,排序,插入 void init(struct data *pdata);//初始化
void reinit(struct data *pdata);//使用之后又一次初始化
void addobject(struct data *pdata, int num);//添加一个元素
void addobjects(struct data *pdata, int *pnum, int n);//添加一个数组
void printfall(struct data *pdata);//打印全部的数据
int * finddata(struct data *pdata, int num);//返回第一个找到数据的地址
void sort(struct data *pdata, int obj);//obj=0,从小大到,否则从到小
void change(struct data *pdata, int oldnum, int newnum);//实现改动
void deleteone(struct data *pdata, int num);//删除第一个找到的数据
void deleteall(struct data *pdata, int num); //删除全部能找到的数据 struct findres findadlldata(struct data *pdata, int num);//返回一片内存,包括全部找到的元素的首地址
void insert(struct data *pdata, int num, int insertnum, int headback);//数据插入
//1代表前面插入,0代表后面插入
#include"动态数组.h" void init(struct data *pdata) //使用之前初始化
{ pdata->p = NULL;//意味着还没有初始化
pdata->length = 0;//长度为0;
pdata->stat = 0;//代表无序
pdata->reallength = 0;//实际长度
} void reinit(struct data *pdata)//使用之后
{
if (pdata->p == NULL)
{
return;
}
else
{
free(pdata->p);//释放内存
pdata->p = NULL;//意味着还没有初始化
pdata->length = 0;//长度为0;
pdata->stat = 0;//代表无序
pdata->reallength = 0;//实际长度
}
} //添加一个数据
void addobject(struct data *pdata, int num)
{
if (pdata->p == NULL)
{
pdata->p = (int *)malloc(sizeof(int));//添加一个元素
pdata->length = 1;//数组标识添加一个元素
pdata->reallength = 1;//实际长度
pdata->p[pdata->length - 1] = num;//赋值
}
else
{
if (pdata->length == pdata->reallength)
{
pdata->p = (int *)realloc(pdata->p, (pdata->length + 1)*sizeof(int));
pdata->length += 1;//数组标识添加一个元素
pdata->reallength += 1;//实际长度
pdata->p[pdata->length - 1] = num;//赋值
}
else
{
pdata->length += 1;//数组标识添加一个元素
pdata->p[pdata->length - 1] = num;//赋值 }
}
} //添加一个数组
void addobjects(struct data *pdata, int *pnum, int n) //数组作为參数退化为指针
{
if (pdata->p == NULL)
{
pdata->p = (int *)malloc(sizeof(int)*n);//添加N个元素
pdata->length = n;//数组标识添加n个元素
pdata->reallength = n;//实际长度
for (int i = 0; i < n; i++)
{
pdata->p[i] = pnum[i];//拷贝数组
}
}
else
{
if (pdata->length+n <= pdata->reallength)
{
for (int i = 0; i < n; i++)
{
pdata->p[i + pdata->length] = pnum[i];//拷贝数组
}
pdata->length += n;//数组标识添加n个元素
}
else
{
pdata->p = (int *)realloc(pdata->p, (pdata->length + n)*sizeof(int));//又一次分配内存
for (int i = 0; i < n; i++)
{
pdata->p[i + pdata->length] = pnum[i];//拷贝数组
}
pdata->length += n;//数组标识添加n个元素
pdata->reallength += n;//添加长度
}
}
} void printfall(struct data *pdata) //打印全部的数组
{
for (int i = 0; i < pdata->length; i++)
{
printf("%d\n", pdata->p[i]);//输出一个数组
}
} void sort(struct data *pdata, int obj)//obj=0,从小大到。否则从da到小
{
if (obj == 0)
{
for (int i = 0; i < pdata->length - 1; i++)
{
for (int j = 0; j < pdata->length - i-1; j++)
{
if (pdata->p[j] > pdata->p[j + 1])// j >j+1
{
int temp = pdata->p[j]; //交换数据
pdata->p[j] = pdata->p[j + 1];
pdata->p[j + 1] = temp;
}
}
}
pdata->stat = 1;//代表从小到大
}
else
{
for (int i = 0; i < pdata->length - 1; i++)
{
for (int j = 0; j < pdata->length - i-1; j++)//冒泡没循环一次。沉底一个极值
{
if (pdata->p[j] < pdata->p[j + 1])// j <j+1
{
//int temp = pdata->p[j]; //交换数据
//pdata->p[j] = pdata->p[j + 1];
//pdata->p[j + 1] = temp;
pdata->p[j] = pdata->p[j] ^ pdata->p[j + 1];
pdata->p[j + 1] = pdata->p[j] ^ pdata->p[j + 1];
pdata->p[j] = pdata->p[j] ^ pdata->p[j + 1];
//0011 0001 3 1
//p[j]0011
//p[j + 1]0001
// p[j] 0010
//p[j + 1]0001
// p[j] 0010
//p[j + 1]0011
// 0001 a=a^b,b=a^b.a=a^b;
}
}
}
pdata->stat = 2;//代表从大到小
}
} int * finddata(struct data *pdata, int num)
{
if (pdata->stat == 0)
{
for (int i = 0; i < pdata->length; i++)//顺序循环
{
printf("查找第%d次\n", i);
if (num == pdata->p[i])//判定是否相等
{
return &pdata->p[i];//返回一个地址
break;//跳出循环
}
}
return NULL;
}
else if (pdata->stat == 1) //二分查找法//从小到da
{
int shang = 0;//shang
int xia = pdata->length - 1;//下
while (shang <= xia)//循环终止条件,
{ int zhong = (shang + xia) / 2;
printf("%d,%d,%d\n", shang, zhong, xia);
if (pdata->p[zhong] == num)
{
return &pdata->p[zhong];//返回地址
}
else if (pdata->p[zhong] >num)
{
xia = zhong - 1;
}
else if (pdata->p[zhong]<num)
{
shang = zhong + 1;
}
}
return NULL; }
else
{
int shang = 0;//shang
int xia = pdata->length - 1;//下 while (shang <= xia)//循环终止条件,
{
int zhong = (shang + xia) / 2;
printf("%d,%d,%d\n", shang, zhong, xia);
if (pdata->p[zhong] == num)
{
return &pdata->p[zhong];//返回地址
}
else if (pdata->p[zhong] >num)
{
//xia = zhong - 1;
shang = zhong + 1;
}
else if (pdata->p[zhong]<num)
{
//shang = zhong + 1;
xia = zhong - 1;
}
}
return NULL;
}
} void change(struct data *pdata, int oldnum, int newnum)//实现改动
{
int *p = finddata(pdata, oldnum);
if (p == NULL)
{
printf("改动失败,没有找到");
return;
}
else
{
*p = newnum;//改动数据
}
} ////1代表前面插入,0代表后面插入
void insert(struct data *pdata, int num, int insertnum, int headback)//数据插入
{
int *p = finddata(pdata, num);//查找数据
if (p == NULL)
{
return ;//没有找到
}
else
{
//找到,前面插入 ,否则后面插入
if (headback==1)
{
if (pdata->length<pdata->reallength)//不须要分配
{
int curr = p - pdata->p;//获取要插入位置的下标
for (int i = pdata->length - 1; i>=curr; i--)
{
pdata->p[i + 1] = pdata->p[i];//从后向前移动
}
pdata->p[curr] = insertnum;//实现插入,前面插入
pdata->length++;//长度加1
}
else
{
int curr = p - pdata->p;//获取要插入位置的下标
pdata->p = (int *)realloc(pdata->p, (pdata->length + 1)*sizeof(int));//添加分配内存
pdata->reallength++;//实际长度+1。
for (int i = pdata->length - 1; i >= curr; i--)
{
pdata->p[i + 1] = pdata->p[i];//从后向前移动
}
pdata->p[curr] = insertnum;//实现插入,前面插入
pdata->length++;//长度加1
}
}
else
{
if (pdata->length<pdata->reallength)//不须要分配
{
int curr = p - pdata->p;//获取要插入位置的下标
for (int i = pdata->length - 1; i > curr; i--)//实现移动
{
pdata->p[i + 1] = pdata->p[i];//从后向前移动
}
pdata->p[curr+1] = insertnum;//实现插入,hou插入
pdata->length++;//长度加1
}
else
{
int curr = p - pdata->p;//获取要插入位置的下标
pdata->p = (int *)realloc(pdata->p, (pdata->length + 1)*sizeof(int));//添加分配内存
pdata->reallength++;//实际长度+1;
for (int i = pdata->length - 1; i > curr; i--)//实现移动
{
pdata->p[i + 1] = pdata->p[i];//从后向前移动
}
pdata->p[curr + 1] = insertnum;//实现插入,hou插入
pdata->length++;//长度加1
}
}
}
} //删除
void deleteone(struct data *pdata, int num)
{
int *p = finddata(pdata, num);//查找数据
if (p == NULL)
{
return ;//没有找到,删除,
}
else
{
int curr = p - pdata->p;//cur就是要删除的下标
//printf("\n%d,%p", *p, p);
//printf("\n%d,%p", pdata->p[curr], &pdata->p[curr]);//输出数据
for (int i = curr; i < pdata->length - 1; i++)
{
pdata->p[i] = pdata->p[i + 1];//从后向前移动
}
pdata->length -= 1;//数组元素减去1
}
} //删除全部
void deleteall(struct data *pdata, int num) //删除全部能找到的数据
{
for (int *p = finddata(pdata, num); p != NULL; p = finddata(pdata, num))
{
int curr = p - pdata->p;//cur就是要删除的下标
//printf("\n%d,%p", *p, p);
//printf("\n%d,%p", pdata->p[curr], &pdata->p[curr]);//输出数据
for (int i = curr; i < pdata->length - 1; i++)
{
pdata->p[i] = pdata->p[i + 1];//从后向前移动
}
pdata->length -= 1;//数组元素减去1 }
} int * find(int *p, int num,int n )//从一个地址開始,N个范围之内找到
{
for (int i = 0; i < n; i++)//循环
{
if (p[i] == num)//推断
{
return p + i;//返回找到的地址
break;
}
}
return NULL;//代表没有找到
} struct findres findadlldata(struct data *pdata, int num)
{
struct findres res1;//构建结构体变量 int i = 0; //统计找到多少个。 for (int *p = find(pdata->p, num, pdata->length - 1);p!=NULL; p = find(p+1, num, (pdata->length - 1)-(p-pdata->p)))
{
i++;
}
res1.n = i;//长度
int **pint = (int **)malloc(sizeof(int *)* i);//指针数组
res1.pp = pint;
for (int *p = find(pdata->p, num, pdata->length - 1),j=0; p != NULL;j++, p = find(p + 1, num, (pdata->length - 1) - (p - pdata->p)))
{
pint[j] = p;//循环赋值
//printf("\n%p,%d\n", pint[j], *pint[j]);
}
return res1;
}
数组库的測试
#include<stdio.h>
#include<stdlib.h>
#include"动态数组.h"
void main()
{ int a[10] = { 231, 112, 1233, 14123, 523, 112, 71, 18, 29, 112 };
struct data data1;
init(&data1);
addobject(&data1, 10);
addobject(&data1, 11);
addobject(&data1, 12);
//reinit(&data1);
addobjects(&data1, a, 10);
printfall(&data1);
insert(&data1, 1233, 1988, 1);
insert(&data1, 1233, 1998, 0);
printfall(&data1);
system("pause");
} void main2()
{
int a[10] = { 231, 112, 1233, 14123, 523, 112, 71, 18, 29, 112 };
struct data data1;
init(&data1);
addobject(&data1, 10);
addobject(&data1, 11);
addobject(&data1, 12);
//reinit(&data1);
addobjects(&data1, a, 10);
printfall(&data1); struct findres resn= findadlldata(&data1, 112);//查找
for (int i = 0; i < resn.n; i++)
{
printf("\nresn %p,%d\n", *(resn.pp+i), **(resn.pp+i));//二级指针遍历指针数组
}
free(resn.pp);//释放内存
printfall(&data1); system("pause");
} void main1()
{
int a[10] = { 231, 112, 1233, 14123, 523,116, 71, 18, 29, 110 };
struct data data1;
init(&data1);
addobject(&data1, 10);
addobject(&data1, 11);
addobject(&data1, 12);
//reinit(&data1);
addobjects(&data1, a, 10);
printfall(&data1); int *pfind = finddata(&data1, 1101);//查找
if (pfind != NULL)
{
printf("%d,%p", *pfind, pfind);//输出查找结果
}
else
{
printf("没有找到奥");
} {
printf("\n\n");
sort(&data1, 0);
printfall(&data1);
int *pfind = finddata(&data1, 523);//查找
if (pfind != NULL)
{
printf("%d,%p", *pfind, pfind);//输出查找结果
}
else
{
printf("没有找到奥");
}
} {
printf("\n\n");
sort(&data1, 1);
printfall(&data1);
int *pfind = finddata(&data1, 523);//查找
if (pfind != NULL)
{
printf("%d,%p", *pfind, pfind);//输出查找结果
}
else
{
printf("没有找到奥");
}
} getchar();
}
|=========== 吴英强CSDN博客专栏==============|
|== C/C++学院 专栏文章的内容(不定期更新)===|
|== linux驱动开发 探索linux底层的奥秘 ==========|
|== Java基础学习篇 掌握java语言的基础知识=====|
|====== 每天进步一点点。健康快乐每一天 ========|
【C/C++学院】0828-数组与指针/内存分配/数据结构数组接口与封装的更多相关文章
- Java学习之旅基础知识篇:数组及引用类型内存分配
在上一篇中,我们已经了解了数组,它是一种引用类型,本篇将详细介绍数组的内存分配等知识点.数组用来存储同一种数据类型的数据,一旦初始化完成,即所占的空间就已固定下来,即使某个元素被清空,但其所在空间仍然 ...
- C/C++指针内存分配小细节
char *pc = NULL; pc = new char[0]; pc[0] = '1'; 相信初学者看见上面这段代码,都会觉得奇怪,new char[n]中的n指定给指针变量分配多少内存空间,而 ...
- Java学习之二维数组定义与内存分配详解
二维数组:就是元素为一维数组的一个数组. 格式1: 数据类型[][] 数组名 = new 数据类型[m][n]; m:表示这个二维数组有多少个一维数组. n:表示每一个一维数组的元素有多少个. 注意: ...
- 05-02 Java 一维数组、内存分配、数组操作
数组的定义 动态初始化 /* 数组:存储同一种数据类型的多个元素的容器. 定义格式: A:数据类型[] 数组名; B:数据类型 数组名[]; 举例: A:int[] a; 定义一个int类型的数组a变 ...
- 20130330 printf数组改变 数组指针便利二维数组 二级指针遍历二维数组 ZigZag
1.为什么printf之后数组的值会改变? #include<stdio.h> ; int * Zigzag() { ,j=,limit=; ; ; int a[N][N]; int (* ...
- java数组复习和内存分配
Java基础知识复习 1.循环 1.1. for循环 for(int i =1;i<=10;i++){ System.out.println("Hello world"+i) ...
- 【嵌入式开发】C语言 内存分配 地址 指针 数组 参数 实例解析
. Android源码看的鸭梨大啊, 补一下C语言基础 ... . 作者 : 万境绝尘 转载请注明出处 : http://blog.csdn.net/shulianghan/article/detai ...
- C语言 内存分配 地址 指针 数组 参数 实例解析
. Android源码看的鸭梨大啊, 补一下C语言基础 ... . 作者 : 万境绝尘 转载请注明出处 : http://blog.csdn.net/shulianghan/article/detai ...
- C++指针与数组、函数、动态内存分配
C++指针 指针是用来存储地址的变量. 对于二维数组来说: a:代表的是首行地址: *a:代表的是首元素地址: **a:首元素: a+1:第二行地址: *a+2:首先*a是首元素地址,在首元素地址上+ ...
随机推荐
- (计数器)NOIP模拟赛(神奇的数位DP题。。)
没有原题传送门.. 手打原题QAQ [问题描述] 一本书的页数为N,页码从1开始编起,请你求出全部页码中,用了多少个0,1,2,…,9.其中—个页码不含多余的0,如N=1234时第5页不是00 ...
- xen 保存快照的实现之 —— device model 状态保存
xen 保存快照的实现之 —— device model 状态保存 实现要点: 设备状态保存在 /var/lib/xen/qemu-save.x 文件这个文件由 qemu-dm 产生,也由 qemu- ...
- cordova学习:事件Events
deviceready: 当cordova完全加载,可以调用cordova API接口 支持平台:Amazon.Fire OS.Android.BlackBerry 10.iOS.Tizen.Wind ...
- UVA 1594:Ducci Sequence (模拟 Grade E)
题意: 对于一个n元组(a0,a1,...),一次变换后变成(|a0-a1|,|a1-a2|,...) 问1000次变换以内是否存在循环. 思路: 模拟,map判重 代码: #include < ...
- 全文索引CONTAINS语法
Like直接在数据据中查找可以查到所有所需记录但是会扫描整个表会影响性能CONTAINS是基于全文索引进行查询,查询结果受系统全文索引分词的方法影响查询结果会不全.Select * FROM A Wh ...
- AC日记——Dining poj 3281
[POJ-3281] 思路: 把牛拆点: s向食物连边,流量1: 饮料向t连边,流量1: 食物向牛1连边,流量1: 牛2向饮料连边,流量1: 最大流: 来,上代码: #include <cstd ...
- 陕西师范大学第七届程序设计竞赛网络同步赛 I 排队排队排队【数组任一位可以移动到队头,最少移动几次增序/数组指针操作】
链接:https://www.nowcoder.com/acm/contest/121/I来源:牛客网 题目描述 ACM竞赛队内要开运动会啦!!!! 竞赛队内的一群阳光乐观积极的队员们迅速的在操场上站 ...
- 在CentOS 7上安装Node.js
一.安装1.进入官网下载最新版本https://nodejs.org/en/ 选择下载后上传或直接使用wget下载 wget https://nodejs.org/dist/v8.11.2/node- ...
- 八. 输入输出(IO)操作4.面向字节的输入输出流
字节流以字节为传输单位,用来读写8位的数据,除了能够处理纯文本文件之外,还能用来处理二进制文件的数据.InputStream类和OutputStream类是所有字节流的父类. InputStream类 ...
- thinkphp3.0增加setInc、setDec方法
thinkphp3.0增加setInc.setDec方法 thinkphp3.0增加setInc.setDec方法,今天查看thinkphp2.0的方法setInc.setDec时是这样写的: 而对于 ...