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

最新推荐文章于 2021-07-21 14:45:21 发布
最新推荐文章于 2021-07-21 14:45:21 发布
阅读量304 收藏
点赞数
分类专栏： 初学c 文章标签： 二级多级指针 指针与数组 多线程并行计算 多线程队列 字符串拷贝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/grepme/article/details/52832217
版权
本文探讨了二级指针的概念和用途，包括多级指针和指针数组的赋值。接着介绍了多线程并行计算和多线程队列的应用，如栈和队列的特性及其在递归加速和线程排序中的作用。此外，还讲解了空类型指针的使用，如何进行类型转换以及如何利用`memset`函数进行字符串拷贝。
摘要由CSDN通过智能技术生成

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 - 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[N] = { 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[N];//优先级
       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[N] = { 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");
}


 

 

 

 

 

 

 

 

 

iweer
关注
专栏目录
【系统架构设计师-2018年】综合知识-答案及详解
数据知道的博客
08-26 2430
遗产数据库是指那些基于旧的、有时过时的技术的数据库，这些技术很少用于开发新的应用程序。最初它用于比较不同的软件体系的体系结构，用来分析SA的可修改性，后来实践证明也可用于其他的质量属性如可移植性、可扩充性等，发展成了评估一个系统的体系结构。设计模式描述了一个出现在特定设计语境中的设计再现问题，并为它的解决方案提供了一个经过充分验证的通用方案，不同的设计模式关注解决不同的问题。通常使用几个捷径来建设原型，这些捷径可能包括使用低效率的、不精确的和虚拟的函数，一个原型通常是实际系统的一个比较粗糙的版本。
c++多线程并发的原理及实现
qq_38338086的博客
12-04 5765
多线程并行处理和实现
pthread_join多线程中关于一个二级指针
mypaomian
08-05 945
#include #include #include #include char message[32]="Hello World!"; void *thread_function(void *arg) { printf("thread_function is runnin
操作系统真象还原实验记录之实验十五：多线程调度
mxy990811的博客
06-20 825
操作系统真象还原实验记录之实验十五：多线程调度 对应书P428 9.4节 1.相关基础知识 2.实验记录 2.1 实验流程 上次实验中，实现了一个线程的运行：具体是 1.申请了一页物理页作为PCB 2.init_thread填写了位于PCB所在物理页最低地址处的PCB结构体 3.thread_create留出位于PCB所在物理页最高地址的中断栈、线程栈的位置，并填写了线程栈的各个成员，其中eip赋值成了函数kernel_thread地址。 4.最后一句内联汇编将esp置为线程栈首地址，ret开启了线程，执行
初识指针4（指针的指针的理解）
yong318585的专栏
11-01 531
#include #include double da = 10.1; double db = 20.1; void changep(double **tt) { *tt = &db; } void main() { double *p = &da; double **pp = &p; changep(&p); printf("\n p1 = %f",
C++二级指针的用法
尘墨
11-18 2575
char **p和char *p[]基本一样， 区别讲不出来，写个例子体会吧。 #include  using namespace std; void main() {     // 第一种初始化方法     char **p = new char *[10];     // 赋值后正常使用     p[0] = "aaa";     cout0]     // 值可
多线程系统实现与线程切换机制解析
在计算机科学与操作系统领域，多线程技术是支持并行处理和提高系统效率的重要技术之一。多线程系统允许多个线程同时执行，从而使得CPU能够在不同线程间快速切换，有效利用资源，增加程序的执行速度和响应时间。本...
golang 解析 --- 进程，线程，协程
hello_bravo_的博客
07-17 2593
一.背景 在并发编程中进程和线程是不可忽略的两个概念，他们很好的完成了操作系统或者服务对于高并发的需求，然而随着时代的进步，协程的概念应运而生，本文旨在解释协程相对于进程和线程在高并发环境下的优势，所以会先介绍进程，线程，最后讲解协程的调度方式。 二.详细介绍 2.1 进程 2.1.1 概念 进程基本上是一个正在执行的程序，它是操作系统中最小的资源分配单位。 2.1.2 结构 当一个程序被加载到内存中并成为一个进程时，它可以分为四个部分——堆栈、堆、文本和数据。下图显示了主内存中进程的简化布局
多进程、多线程、多核CPU——(I)
热门推荐
_Jomie
05-02 5万+
前言 在介绍多线程时，首先分析进程、以及多道程序设计模型。进程是操作系统中最重要的抽象概念之一，使得在即使只有一个CPU的机器上，也支持（伪）并发，即将一个单独的CPU变成多个虚拟的CPU。 多到程序设计 在进程执行过程中常常会因为资源请求或者IO被阻塞或中断（有的请求或者中断需要处理很长时间），此时CPU便空闲出来，众所周知，CPU是计算机中非常宝贵的资源，为提高其利用率，操作系统需通过进
互联网面试知识点总结（二）- 操作系统篇
wanglizhi3733的博客
04-25 426
面试题笔记（一）- C++篇 19 请你说说fork函数
linux c多线程与消息队列实现字符串转化
qq_26391203的博客
07-17 1752
编写一个具有3个子线程的程序，Thread 1从标准输入设备获取一个字符串，并将该字符串发送到消息队列；Thread 2 从消息队列获取该字符串，并将其反转，然后重新发送到消息队列；Thread 3读取Thread 2 发送的消息字符串，并将字符串中的大写字符变为小写，小写字符变为大写；将最终字符串最为结束状态，返回到主线程。主线程显示Thread 3的退出状态。 #include
二级指针与ARC不为人知的特性
Night_SaaS的博客
03-15 326
先看一眼熟知的代码 1 2 3 4 5 6 7 8 9 10 11 12 13 - (void)viewDidLoad {     [super viewDidLoad];       NSData *data = [@"{\"key\":\"value\"}"
汇编中使用多线程技术（非常简单）
caojapan的专栏
07-24 1532
以下是一个实例，说明：_ShowBmpThread proc uses ebx esi edi,_lParam（这种格式是WIN32API中指定的格式，注意那个参数，_lParam,必须有（1个））调用过程： _ShowBmp proc  hWinMain:DWORD(里面最关键的就是 invoke CreateThread,NULL,0,addr _ShowBmpThread,hWi
c语言基本类型和指针
chuyouyinghe的专栏
10-13 1164
//导入标准函数库（类似于java的导包） #include //导入标准函数库（system、sizeof等等......） #include //windows系统的api #include /* void main(){ //输出函数 printf("hello world!"); //这是一个命令（在window里面特有的） system("pause"); } */ /
并行计算基础（2）
dianshu9815的博客
08-29 496
一、CPU和GPU交互 1.各自有自己的物理内存空间，CPU的是内存，GPU的是显存 2.通过PCI-E总线互连(8GB/S~16GB/S) 3.交互开销较大 GPU各存储访存速度： Register寄存器，最快 Shared Memory，共享存储，很快 Local Memory，本地存储，在显存中，有缓存，相对较慢 Global Memory，全局存储...
C语言中的多级指针
十三阿哥的博客
07-21 2290
前言：C语言中指针的操作非常灵活，指针与数组的结合更是令初学者晕头转向，一级指针倒还可以，二级及其以上，也即是所谓的多级指针，就使得大部分初学者更混淆了，今天趁着美好时光，以图文并茂的形式形象的解释一下二级及其以上的指针的用法！ 1.首先看一级指针： #include <iostream> using namespace std; int main() { int a = 1; int* pA = &a; //pA是一级指针，指向变量a所在的内存 return 0; } 抽
理解指针与数组：传递方式与函数指针应用
本文档主要探讨了指针与数组在编程中的区别以及相关的实验和指导案例。首先，通过一个C++程序示例，介绍了实参与形参的传递方式。在`swap`函数中，通过指针`pointer_1`和`pointer_2`交换整数a和b的值，展示了如何...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值