4-18-2-二级多级指针、指针与数组、多线程并行计算、多线程队列、字符串拷贝

5、二级指针（指向指针的指针）

double num=10.8;
double *p = #
double **pp = &p;//*（*pp）两个星，*pp读取p地址的内容（num的地址），*(*pp)再根据p内容去找到num的位置，读取num的数值
double *px = &p;//不合法
printf("num=%f,*p=%f,**pp=%f\n",num, *p, **pp);//都是10.800000
printf("*px=%p\n", *px);//输出p的地址
printf("%p,%p\n", px, px +1);//后者比前者加了8个字节，容易读取出界
printf("%p,%p", pp, pp + 1);//后者比前者加了4字节
用途

#include<stdio.h>
#include<stdlib.h>
int a = 10;
int b = 20;
void change(int*p)
{
p = &b;//这里的p并不是main里面的p，虽然都指向a的地址
//将b的地址赋给一个陌生的指针，main的p并没有改变
}
void changepp(int**pp)
{
*pp = &b;//这里的pp虽然只是个副本，但是传递的p的地址是真实的，相当于在main里执行p=&b
}
void main()
{
int *p = &a;
printf("%d\n", *p);//10
change(p);
printf("%d\n", *p);//10
changepp(&p);
printf("%d", *p);//20
system("pause");
}
多级指针

int a = 10;
int *p = &a;
int **pp = &p;
int ***ppp = &pp;
printf("%p", &ppp);
//四字节整数，16进制显示
//ppp 地址 0x006FFA80 内容0x006FFA8C
//pp 地址 0x006FFA8C 内容0x006FFA98
//p 地址 0x006FFA98 内容0x006FFAA4
//a 地址 0x006FFAA4 内容0000000a 带符号显示为10

//不要对*p直接赋值，存储在代码区
char *px = "123";
printf("px=%p", px);


指针数组赋值

#include<stdio.h>
#include<stdlib.h>
voidrun(char*a[5])
{
printf("\n run=%d",sizeof(a));//4
for (int i = 0; i < 5; i++)
{
system(a[i]);
}
}
//int a[5] int*a
//char *a[5]char **a
void run1(char**a)//指针数组作为指针退化为二级指针
{
printf("\n run=%d",sizeof(a));//4
for (int i = 0; i < 5; i++)
{
system(a[i]);
}
}
void main()
{
char * a[5] = {"calc","notepad","mspaint","tasklist","pause"};
printf("%d\n", sizeof(a));//20
run(a);
run1(a);
//run run1 等价
system("pause");
}


6、指针数组

int a[10] = {1,2,3,4,5,6,7,8,9,0 };
int *p = a;
for (int i = 0; i < 10; i++)
{
printf("\n%d,%d,%d,%d",a[i], *(a + i),p[i],*(p+i));
}

//a[i],*(a+i) 等价

//,p[i],*(p+i) 等价

所以 printf("%d",3[a]);//输出结果为4

 

#include<stdio.h>
#include<stdlib.h>

void rev(int *p,int n)
{
for (int i = 0; i < n / 2; i++)
{
int temp = p[i];
p[i] = p[n - 1
4000
- i];
p[n - 1 - i] = temp;
}
}
void revp(int*p, int n)
{
for (int *phead = p, *pback = p + n - 1;phead < pback; phead++, pback--)
{
int temp = *phead;
*phead = *pback;
*pback = temp;
}
}
void show(int*p, int n)
{
for (int i = 0; i < n; i++)
{
printf("%4d", p[i]);
}
}
void main()
{
int a[10] = { 1,2,3,4,5,6,7,8,9,0 };
int b[9] = { 1,2,3,4,5,6,7,8,9 };
//rev(a, sizeof(a) / sizeof(a[0]));//求数组长度的公式sizeof(a)/ size(a[0])
revp(a, sizeof(a) / sizeof(a[0]));
show(a, sizeof(a) / sizeof(a[0]));
system("pause");
}
7、多线程并行计算

#include<stdio.h>
#include<stdlib.h>
#include<process.h>
#include<Windows.h>
#include<time.h>
#define N 1024
#define M 8

struct Myinfo
{
int *pstart;//开始地址
int id;//线程编号
int length;//长度
int sum;//存储数据的和
};//(&info)->length等价于info.length
void add(void*p)//void *p可以保存任何类型的指针
{
struct Myinfo *pinfo = p;
for (int i = 0; i < pinfo->length;i++)
{
pinfo->sum +=pinfo->pstart[i];
}
printf("线程%d计算的结果%d\n", pinfo->id, pinfo->sum);

}
void main()
{
time_t ts;
unsigned int num = time(&ts);
srand(num);
int data
= { 0 };
for (int i = 0; i < N; i++)
{
data[i] = rand() % 1000;
//printf("%4d",data[i]);
}
int sum = 0;
for (int i = 0; i < N; i++)//单线程求和
{
sum += data[i];
}
printf("\n单线程总和=%d\n",sum);

struct Myinfo info[M] = { 0 };
for (int i = 0; i < M; i++)
{
info[i].id = i;
info[i].length = N / M;
info[i].sum = 0;
info[i].pstart = data + i*N / M;
_beginthread(add, 0,&info[i]);
}
system("pause");
int lastsum=0;
for (int i = 0; i < M; i++)
{
lastsum += info[i].sum;
}
printf("\n多线程总和=%d",lastsum);
system("pause");
}

 

8、多线程排队

#include"queue.h"
#define N 1024
#define M 8
struct queuemyQ;//结构体队列，所有线程共享

struct Myinfo
{ //int dataX
;//优先级
int *pstart;//开始地址
int id;//线程编号
int length;//长度
int sum;//存储数据的和
};
void add(void*p)//void *p可以保存任何类型的指针
{
struct Myinfo *pinfo = p;
for (int i = 0; i < pinfo->length;i++)
{
pinfo->sum +=pinfo->pstart[i];
}
enqueue(&myQ, pinfo->id);
printf("线程%d计算的结果%d\n", pinfo->id, pinfo->sum);
}

void main()
{
init(&myQ);

time_t ts;
unsigned int num = time(&ts);
srand(num);
int data
= { 0 };
for (int i = 0; i < N; i++)
{
data[i] = rand() % 1000;
//printf("%4d",data[i]);
}
int sum = 0;
for (int i = 0; i < N; i++)//单线程求和
{
sum += data[i];
}
printf("\n单线程总和=%d\n",sum);

struct Myinfo info[M] = { 0 };
for (int i = 0; i < M; i++)
{
info[i].id = i;
info[i].length = N / M;
info[i].sum = 0;
info[i].pstart = data + i*N / M;
_beginthread(add, 0,&info[i]);
}
system("pause");
show(&myQ);
int lastsum = 0;
for (int i = 0; i < M; i++)
{
lastsum += info[i].sum;
}
printf("\n多线程总和=%d",lastsum);
system("pause");
}
栈：先进后出。作用：递归加速、缓冲、顺序逆序输出

队列：先进先出。作用:排队、线程排序

 

9、空类型指针 

void*p;// 空类型指针

空类型指针可以指向任何类型的数据或者指针，但是不能打印数据

 

*((doble*)p)=20.8;//但是可以强制转化

printf("%d",*((double)p));//强制转化后也可以打印了

//转换类型后，明确从地址开始，读取几个字节

 

函数memset

memset(str,0,20);//从字符串（或数组）str首地址开始，前进20个字节，进行赋值数字（或者字符）0

 

10、字符串拷贝

#define_CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
#include<string.h>

char*mystrcpy(char *dest, char *source)
{
char *last = NULL;//最后的结果
if (dest == NULL || source == NULL)
{
return last;//直接返回空指针，没有任何操作
}
last = dest;//存入dest首地址
//没有遇到字符’/0‘，就继续拷贝
while ((*dest++ = *source++) != '\0');
//while (*source != '\0')//效果等同
//{
// *dest= *source;
// dest++;
// source++;
//}
return last;

}
void main()
{
char str[40] = {0};
//printf("%s", strcpy(str,"hello world"));
printf("%s", mystrcpy(str,"hello world"));
system("pause");
}