C和指针与相关应用

最新推荐文章于 2024-11-14 22:16:00 发布
最新推荐文章于 2024-11-14 22:16:00 发布
阅读量350 收藏 1
点赞数 3
文章标签： c语言 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a695415974/article/details/122512348
版权

C和指针与相关应用

指针的基础知识

  • 指针是C语言的一个重要的概念,也是C语言的一个重要特色
  • 从地址可以找到内存中存储的相关数据,这个地址对应的就是C语言中的指针
  • 指针指向的是数据在内存中的地址,而不是指向内存中内容

&是取内容运算符
就是可以通过变量名，找到这个变量名对应的地址
比如:int a=0,printf("%p",&a) 此时&a就对应于变量a在内存中储存的地址

*是指针运算符
可以通过地址，找到这个地址里面的变量
比如:int a=0,*p;p=&a; 此时p就等同于变量a*,也是是指针p指向的对象,而p就等同于变量a的地址

对于int a=0,*p;p=&a;来说,*p(指针p指向的对象a)等价于a(原本的对象a)
对于int a=0;int *p;//此时需要对*p进行初始化 *p=a;来说,*p等于a的内容,此时a的地址和p指向的地址不是一样的 而且必须对*p进行初始化

  • 1、*p=a的意思是:将a的值赋给p指针指向的地址的值;
  • 2、p=&a的意思是:将a的地址赋给指针p;
#include <stdio.h>
//指针变量 和 指针的区别
int main()
{
    int anum = 10;
    int bnum = 20;
    int *a,*b;
    //a,b 为 指针变量 此时指向空地址
    //&取地址符号 将后者地址赋值给前者指针变量
    a = &anum;
    b = &bnum;
    printf("anum = %d,bnum = %d\n",anum,bnum);
    //%p 输出地址 将指针输出 指针本质是十六进制的地址
    printf("a's addr = %p,b's addr = %p\n",a,b);
    //*取内容符号 输出地址对应存储的内容
    printf("a's num = %d,b's num = %d\n",*a,*b);
	return 0;
}

此时指针a,b的地址是不一样的 是两个不同的指针变量
但是a和b指向的地址和内容与anum/bnum是一致的

指针变量的基础应用

  • 1.使用指针变量 交换两个数的值
#include <stdio.h>
//用指针交换两个数
//输入两个数 按大小输出
int main()
{
    int a,b,temp;
    scanf("%d%d",&a,&b);
	//a1,b1 为 int型指针变量 此时指向空地址
    int *a1,*b1;
	//把a的地址赋值给a1 把b的地址赋值给b1
    a1 = &a;
    b1 = &b;
    if(a<b){
     //用temp交换a1和b1指向的内容
	 //实际上是使用temp中间变量交换了a1和b1指向的a和b的内容
     temp = *a1;
     *a1 = *b1;
     *b1 = temp;
    }
    printf("max = %d,min = %d\n",a,b);
	return 0;
}
  • 2.也可以使用指针变量作为函数的参数进行传递
#include <stdio.h>
//用指针交换两个数 函数版
//输入两个数 按大小输出

void swaps(int *a1,int *b1){
    // 此时a1,b1为指针变量
    //*a1就是a,*b1就是b
    //交换a,b两变量的值
    int temp;
    temp = *a1;
    *a1 = *b1;
    *b1 =temp;
}
int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
	//a1,b1 为 指针变量 此时指向空地址
    int *a1,*b1;
	//把a的地址赋值给a1 把b的地址赋值给b1
    a1 = &a;
    b1 = &b;
    if(a<b){
     //向swaps方法传入指针变量参数 并交换指针变量a1和指针变量b1指向的地址存储的值
     swaps(a1,b1);
    }
    printf("max = %d,min = %d\n",a,b);
	return 0;
}
  • 3.还可以在嵌套调用中使用指针的办法
#include <stdio.h>
//用指针排序三个数 嵌套调用的方法
//输入三个数 按由大到小输出
void exchange(int *a1,int *b1,int *c1){
    //*a1<*b1 交换a,b两数的值
    if(*a1<*b1){
        swaps(a1,b1);
    }
    //*a1<*c1 交换a,c两数的值
    if(*a1<*c1){
        swaps(a1,c1);
    }
    //*b1<*c1 交换a,b两数的值
    if(*b1<*c1){
        swaps(b1,c1);
    }
}

void swaps(int *a1,int *b1){
    // 此时a1,b1为指针变量
    //*a1就是第一个参数,*b1就是第二个参数
    //交换a,b存储的值
    int temp;
    temp = *a1;
    *a1 = *b1;
    *b1 =temp;
}

int main()
{
    int a,b,c;
    scanf("%d%d%d",&a,&b,&c);
	//a,b,c 为 指针变量 此时指向空地址
    int *a1,*b1,*c1;
	//把a的地址赋值给a1 把b的地址赋值给b1 把c的地址赋值给c1
    a1 = &a;
    b1 = &b;
    c1 = &c;
	//向swaps方法传入指针变量参数 并按情况交换指针变量a1,指针变量b1和指针变量c1 指向的地址存储的值
    exchange(a1,b1,c1);
    printf("%d %d %d\n",a,b,c);
	return 0;
}

通过指针引用数组

  • 1.通过指针引用数组的方法
	int arr[7] = {1,9,19,8,1,0,0};
	//arr是数组的首地址 arr可以作为指针变量
	int *p = arr;
	//&arr[0]是该数组的首个元素的地址
	int *p1 = &arr[0];
	//*arr是取数组的首地址存储的值
	int arr1 = *arr;
	//arr[0]是取数组的首个元素的值
	int arr2 = arr[0];

注:
数组名就是一个指向数组第一个元素的指针变量
p指向的是arr的第一个元素的地址 也是数组的首地址
&arr[0]是该数组的首个元素的地址 p=p1=&arr[0]=arr=某个十六进制的地址
*arr是取数组的首地址存储的值
arr[0]是取数组的首个元素的值 arr2=arr1=arr[0]=*arr=1

  • 2.通过指针引用数组的应用
#include <stdio.h>
//指针和数组的相关应用
void outputarr(int arr[]){
    //接受传入的数组首地址
	//顺序打印数组
    for(int *a=arr;a<arr+7;a++){
        printf("%d ",*a);
    }
}

int main()
{
    int arr[7] = {1,9,19,8,1,0,0};
    //arr是数组的首地址 arr可以作为指针变量
    int *p = arr;
    //&arr[0]是该数组的首个元素的地址
    int *p1 = &arr[0];
    printf("CASE 1\n%p %p\n",p,p1);
    //*arr是取数组的首地址存储的值
    int arr1 = *arr;
    //arr[0]是取数组的首个元素的值
    int arr2 = arr[0];
    printf("%d %d\n",arr1,arr2);
    //p+4 是取数组的首地址的p+16 即(4*sizeof(arr)) 指向arr第五个元素的首地址
    p = p+4;
    //&arr[4] 是取数组的第五个元素地址
    p1 = &arr[4];
    printf("CASE 2\n%p %p\n",p,p1);
    //*(arr+4)是取数组的首地址的p+16的地址值
    arr1 = *(arr+4);
    //arr[4]取数组的第五个元素的值
    arr2 = arr[4];
    printf("%d %d\nCASE 3\n",arr1,arr2);
    //用数组指针遍历arr 方法1
    for(int *a=arr;a<arr+7;a++){
        printf("%d ",*a);
    }
    printf("\nCASE 4\n");
    //用数组指针遍历arr 方法2
    for(int *a=&arr[0];a<arr+7;a++){
        printf("%d ",*a);
    }
    printf("\nCASE 5\n");
    //用数组指针遍历arr 用数组名(一个指向数组第一个元素的指针变量)做参数 方法3
    outputarr(arr);
	return 0;
}
  • 3.通过指针引用多维数组
    多维数组的指针使用方法基本和一维数组类似
#include <stdio.h>
//指针和二维数组
void outputarr(int arr[][2]){
    printf("CASE 5\n");
    //接受传入的二维数组首地址 并循环输出
    for(int *a=&arr[0][0];a<arr+2;a+=1){
        printf("%d ",*a);
        if((a-&arr[0][0])%2!=0){
            printf("\n");
        }
    }
}

int main()
{
    int arr[2][2] = {{1,9},{8,1}};
    //arr是二维数组的第一行首地址
    int *p = arr;
    //&arr[0]是该二维数组的第一行的首个元素的地址
    int *p1 = &arr[0];
    printf("CASE 1\n %p %p\n",p,p1);
    //*arr[0]是取二维数组的第1行第1列存储的值
    int arr1 = *arr[0];
    //arr[0][0]是取二维数组的第1行第1列存储的值
    int arr2 = arr[0][0];
    printf("%d %d\n",arr1,arr2);
    //p+1 是取二维数组的第一行首地址的p+16 即(2*sizeof(arr)) 指向arr第2行的首地址
    p = p+1;
    //&arr[1] 是取二维数组的第二行第一个元素的地址
    p1 = &arr[1];
    printf("CASE 2\n%p %p\n",p,p1);
    //*(arr+1)是取二维数组的第二行的（第一个元素）首地址 *(arr+1)+1 为第二行第二个元素的地址 *(*(arr+1)+1)为取数组第二行第二个元素的值
    arr1 = *(*(arr+1)+1);
    //arr[1][1]取二维数组第二行第二个元素的值
    arr2 = arr[1][1];
    printf("%d %d\n",arr1,arr2);
    printf("CASE 3\n");
    //用数组指针遍历arr 方法1
    for(int *a=&arr[0][0];a<arr+2;a+=1){
        printf("%d ",*a);
        if((a-&arr[0][0])%2!=0){
            printf("\n");
        }
    }
    printf("CASE 4\n");
    //用数组指针遍历arr 方法2
    for(int *a=arr;a<arr+2;a+=1){
        printf("%d ",*a);
        if((a-arr[0])%2!=0){
            printf("\n");
        }
    }
    //用数组指针遍历arr 用二维数组首地址做参数 方法3
    outputarr(arr);
	return 0;
}

通过指针引用字符串

通过指针引用字符串的原理和通过指针引用数组是类似的

#include <stdio.h>
//引入memset函数
#include <string.h>
//指针和字符串和相关操作 定义strcopy方法
void strcopy(char str[],char str1 []){
    for(char *c = str,i=0 ; *c!='\0';c++,i++){
        str1[i] = *c;
    }
}

int main()
{
    char str[]="HELLO WORLD!!!";
    char str1[15];
    //str是字符数组的起始地址
    //%s输出str串
    printf("%s\n",str);
    //*str输出str第一个元素
    printf("%c\n",*str);
    //a串赋值到b串 方法1 老办法
    for(int i = 0 ; i < sizeof(str);i++){
        str1[i] = str [i];
    }
    printf("CASE 1 \n%s\n%s\n",str,str1);
	//清空字符串str1
    memset(str1,'\0',sizeof(str1));
    //a串赋值到b串 方法2 将str首地址赋值到字符指针上
    for(char *c = str,i=0 ; c < str + sizeof(str)&&*c!='\0';c++,i++){
		//把c指向的字符内容赋值到相对应的str1的位置上
        str1[i] = *c;
    }
    printf("CASE 2 \n%s\n%s\n",str,str1);
    //清空字符串str1
	memset(str1,'\0',sizeof(str1));
    //a串赋值到b串 方法3 数组作参数
    strcopy(str,str1);
    printf("CASE 3 \n%s\n%s\n",str,str1);
	return 0;
}

字符指针变量和字符数组的区别

  1. 两者的声明不一样
    字符数组 char str[20];
    字符指针变量 char str[20];char *p=str;
  2. 字符数组由若干个元素组成,每个元素都是一个字符 而 字符指针变量是存放的指向一个字符类型的变量的地址
  3. 赋值方式不同
    可以对字符指针赋值 不能对数组名赋值
	char *a;  //声明一个字符指针变量
	a = "I love China!"; //把字符串的首地址赋值给字符指针变量 赋值给a的是首地址 并不是内容

	char str[14];  //声明一个字符数组
	str[0] = 'I'; //合法 对数组元素赋值
	str = "I love China!"; //不合法 不能给指针对应的地址赋值
  1. 编译时 为字符数组分配足够多的存储单元 而字符指针变量只分配一个存储单元
  2. 指针变量的值可以改变 但是数据名对应的值不能改变
#include <stdio.h>
    int main(){
		char *a = {"I love China!"};
		a = a+7; //正确 a是指针变量 可以改变值
		printf("%s\n",a);
		return 0;
	}

#include <stdio.h>
    int main(){
		char str[] = "I love China!";
		str= str+7; //错误 数组名不能改变
		printf("%s\n",str);
		return 0;
	}
  1. 字符数组的各个元素可以改变 , 字符指针变量指向的字符串是个常量不能改变
		char str[] = "I love China!";
		str[2] = 'r'; //合法 可以对字符数组进行重新赋值
		char *a = "I love China!";
		a[2] = 'r'; //不合法 不可以对字符串常量进行重新赋值
		return 0;

指向函数的指针

定义一个指向函数的函数指针变量
比如

int max(int a,int b){ return a>b?a:b;}
int (*p)(int,int) = max;

使用(*p)(a,b) 来代替 max(a,b)的调用

#include <stdio.h>
//函数指针
//输入三个数 输出最大和最小的数
//定义函数max2num
int max2num(int a,int b)
{
    //返回两数最大值
    return a>b?a:b;
}
//定义函数max3num
int max3num(int a,int b,int c)
{
    int maxnum;
    //定义三个两个参数的函数指针p,p1,p2 指向max2num
    int (*p)(int,int) = max2num;
    int (*p1)(int,int) = max2num;
    int (*p2)(int,int) = max2num;
    //调用三次max2num函数 获得最大值
    return (*p2)((*p)(a,b),(*p1)(b,c));
}
//定义函数min2num
int min2num(int a,int b)
{
    //返回两数最小值
    return a<b?a:b;
}
//定义函数min3num
int min3num(int a,int b,int c)
{
    int minnum;
    //定义三个两个参数的函数指针p,p1,p2 都指向min2num函数
    int (*p)(int,int) = min2num;
    int (*p1)(int,int) = min2num;
    int (*p2)(int,int) = min2num;
    //调用三次min2num函数 获得最小值
    return (*p2)((*p)(a,b),(*p1)(b,c));
}
//定义指针型函数output
void *output(int a,int b,int c)
{
    //定义一个三个参数的函数指针p 指向max3num函数
    int (*p)(int,int,int) = max3num;
    //定义一个三个参数的函数指针p1 指向min3num函数
    int (*p1)(int,int,int) = min3num;
    //通过指针调用函数 (*p)(a,b,c)返回最大值 (*p1)(a,b,c)返回最小值
    printf("maxnum is %d minnum is %d",(*p)(a,b,c),(*p1)(a,b,c));
}
int main()
{
    int a,b,c;
    scanf("%d %d %d",&a,&b,&c);
    //声明一个函数指针
    int (*p)(int,int,int);
    //指向指针型函数
    p = &output;
    //调用指针型函数
    p(a,b,c);
	return 0;
}

返回指针值的函数

返回指针值的函数的声明
表示声明一个叫maxn的函数 该函数的返回值类型是指向int型变量的一个指针值

int *maxn(int a,int b){
}

#include <stdio.h>
//返回指针值的函数maxn 返回的是指向一个int型变量指针值
int *maxn(int a,int b){
    int *temp ;
    temp = a>b?&a:&b;
    return temp;
}

int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
	//接收该指针值
    int *temp =maxn(a,b);
	//输出该指针指向的数据
    printf("the max number is %d",*temp);
	return 0;
}

指针数组

指针数组的声明
数据类型名 * 数组名[数组长];
注意不能写成
数据类型名 (* 数组名)[数组长];
前者是一个指针数组 数组的每一个元素都是一个指针 而后者定义一个指向一维数组的指针

#include <stdio.h>
#include <string.h>
//指针数组
//使用指针数组排序多个字符数组 使用指针数组作为参数传入函数内部
void sortstr(char *str[])
{
    char *temp;
    int i,j,k;
    //冒泡排序的相关代码
    for( i = 0 ; i < 4; i ++)
    {
        k = i;
        for(j=i+1; j<5; j++)
        {
            if(strcmp(str[k],str[j])>0)
            {
                k = j;
            }
        }
        if(k != i)
        {
            //交换不同指针指向的字符串内容
            temp = str[i];
            str[i] = str[k];
            str[k] = temp;
        }
    }
}
//输出指针数组
void printstr(char *str[])
{
    for(int i=0; i<5; i++)
    {
        printf("%s\n",str[i]);
    }
}
int main()
{
	//定义一个指向五个字符数组的指针数组str
    char *str[]= {"banana","cheer","cheems","apple","microsoft"};
	//使用指针数组的首地址作为参数 传入sortstr方法进行排序
    sortstr(str);
	//使用指针数组的首地址作为参数 传入printstr方法进行顺序输出
    printstr(str);
	return 0;
}

内存的动态分配

常用的内存分配函数有malloc,free,realloc,calloc
这些源文件都包含在stdlib.h头文件内
malloc
原型定义 void *malloc(size_t size)
参数是需要划分的内存的大小 单位是字节数
返回的是无类型的指针 需要手动转换为需要的数据类型
比如

	char *p;
    //用malloc动态分配内存区域给p
    p = (char *) malloc(10*sizeof(char));//强制转换为需要的数据类型

free
原型定义 void free(void *ptr)
释放之前调用 calloc、malloc 或 realloc 所分配的内存空间。
比如

	char *p;
    //用malloc动态分配内存区域给p
    p = (char *) malloc(10*sizeof(char));//强制转换为需要的数据类型
	//释放分配的内存空间
	free(p);

realloc
原型定义 void *realloc(void *ptr, size_t size)
尝试重新调整之前调用 malloc 或 calloc 所分配的 ptr 所指向的内存块的大小。
参数是之前分配好内存的指针变量和需要重新划分的内存的大小 单位是字节数
返回的是无类型的指针 需要手动转换为需要的数据类型 如果请求失败，则返回为 NULL。
比如

	char *p;
    //用malloc动态分配内存区域给p
    p = (char *) malloc(10*sizeof(char));//强制转换为需要的数据类型
	//调整之前分配的内存空间
	realloc(p,20*sizeof(char));

calloc
原型定义 void *calloc(size_t nitems, size_t size)
分配所需的内存空间，并返回一个指向它的指针。
主要是为了开辟动态的内存区
参数是需要划分的区域的个数nitems 和每个区域的字节数size
返回的是无类型的指针 需要手动转换为需要的数据类型

	char *p;
    //用calloc动态分配内存区域给p
    p = (char *) calloc(50,sizeof(char));//强制转换为需要的数据类型

#include <stdio.h>
#include <stdlib.h>
int main()
{
//定义指针数组
    char *p;
    //用malloc动态分配内存
    p = (char *) malloc(10*sizeof(char));
	//p = (char *) calloc(50,sizeof(char));
    scanf("%s",p);
    //三种输出方式
    puts(p);
    printf("%s\n",p);
    char *temp = p;
    for(int i=0;i<10&&*(temp)!='\0';i++){
        printf("%c",*(temp++));
    }
    printf("\n");
    //realloc不太容易成功 有可能返回NULL 导致程序闪退
    realloc(p,20*sizeof(char));
    free(p);
    //free之后再printf会报错或闪退
    //printf("%d\n",p[0]);
	//用calloc重新动态分配内存
    p = (char *) calloc(50,sizeof(char));
	//使p[0]为'c'
    p[0]='1';
    printf("%c\n",p[0]);
    return 0;
}

c和指针的相关小结

  1. 使用指针时要注意不要越过数组的上界与下界 如果数组越界可能会导致程序闪退或报错
  2. 使用指针变量之前一定要初始化，否则可能出现野指针的问题 使用这个指针有可能导致程序闪退或报错
  3. 两个指针变量可以相减。两个指针相减则表示两个指针相差的元素个数 至少需要保证这两个指针都是指向一个数组的不同元素的合法指针
  4. 常见的指针的应用如下
定义含义
int *p;定义指向一个整形数据的指针p
int **p;定义指向一个整形数据的指针变量的指针变量p
int *p[n];定义指针数组p,该指针数组的每个元素都是一个单独的指针变量
int (*p)[n];定义指向拥有n个元素的一维数组的指针变量p
int *p();定义返回值类型为指向一个整形变量的函数p()
int (*p)();定义一个函数指针p,指向返回值为整形变量的一个方法比如int func(),可以用 (*p)()来代替func()的调用
Johnny-He
关注
C语言函数指针与指针函数训练.zip
01-14
在C语言中，函数指针和指针函数是高级特性，它们在编程中扮演着重要角色，尤其是在处理回调函数、动态调度以及实现元编程等方面。本训练将深入讲解这两个概念，帮助你掌握其核心概念和实际应用。 首先，我们要了解...
2.7节 C语言10.10
05-09 225
C语言10.10 时间限制:1 Sec内存限制:32 MB 题目描述 给定字符串定义char *a = “I love China!”，读入整数n，输出在进行了a = a + n这个赋值操作以后字符指针a对应的字符串。 输入 一个整数n，保证0<=n<13....
C语言小练习：给定一串字符“I love china“,实现以单词为单位的逆序，如：“china love I“
lkc201314的博客
03-03 810
给定一串字符"I love china",实现以单词为单位的逆序，如："china love I"
(2.7C)指针与字符串
欢迎来到爱吃橘子的程序媛的代码妙妙屋！
01-24 320
问题： 代码： #include<stdio.h> int main(){ char* a="I love China!";//指针a指向字符串的首地址 //printf("%c",*a); int n; scanf("%d",&n); a=a+n;//相当于这个字符串的起始地址往后挪了n printf("%s\n",a);//这里不是*a，而是a（识别一个地址，把从它开始的字符串输出 ） return 0; }
C语言基础学习
weixin_42989738的博客
01-07 474
C语言学习 1字符的获取与输出 #include&lt;stdio.h&gt; int main() { char *Char =“I Love China!”; // c语言中对于单个字符操作比较麻烦，因此需要用字符串的形式，利用gets和puts进行处理 puts(“I Love China!\n”); puts(“I\0Love\0China\n”);// \0是结束符 puts(Char)...
C语言指针学习（3）
weixin_61725225的博客
02-04 2068
1.字符串的引用方式 在C语言程序中，字符串是存放在字符数组中的，想引用一个字符串，可以用以下俩种方法 （1）用字符数组存放一个字符串，可以通过数组名和下标引用字符串其中一个字符，也可以用数组名和格式声明“%s”输出字符串 【例题】定义一个字符数组，在其中存放字符串“I love China!”输出该字符串和第八个字符 #include<stdio.h> int main() { char string[]="I love China!"; //定义字符数
C语言指针应用简单实例
08-30
在本篇文章中，我们将探讨C语言指针应用的一个简单实例——如何使用指针来交换两个整数变量的值。 首先，让我们看一个简单的交换函数，但这个函数并没有使用指针： ```c void swap(int x, int y) { int temp; ...
C语言指针的详解与应用.pptx
10-24
C语言指针的详解与应用 C语言指针是C语言的一个重要知识点，其使用灵活、功能强大，是C语言的灵魂。指针与底层硬件联系紧密，使用指针可操作数据的地址，实现数据的间接访问。 指针的定义 ---------------- 指针...
C语言中指针基本概念及应用详解
11-14
内容概要：本文详细讲解了C语言中的指针概念及其应用技巧，涵盖指针的基本概念、初始化与赋值、访问变量的值、与数组的关系、指针的运算以及多级指针等内容，并提供了多个实例帮助读者加深理解和掌握。 适用人群：...
C语言-数组、结构体与指针的综合应用实验报告
01-09
【C语言-数组、结构体与指针的综合应用实验报告】 本次实验旨在掌握C语言中数组、结构体和指针的基本用法，以及初步理解链表的概念和操作。实验内容涉及设计一个结构体来存储学生信息，包括学号、姓名、三科成绩和...
给定字符串定义char *a = “I love China!”，读入整数n，输出在进行了a = a + n这个赋值操作以后字符指针a对应的字符串
qq_41129306的博客
06-16 5560
输入 一个整数n，保证0<=n<13. 输出 输出进行了题目描述中赋值操作之后a对应的字符串。 请注意行尾输出换行。 样例输入 7 样例输出 China! #include<stdio.h> #include<string.h> int main() { const char *a="I love China!"; int n; ...
【PGCCC】Postgresql 存储设计
PGCCC的博客
11-14 576
postgresql 的这种设计应该是基于磁盘考虑的，因为我们大部分的存储介质都是磁盘，磁盘都是由固定大小的扇区组成，一般是512字节。我们还需要一些描述 Buffer 的信息，比如该 Buffer 对应哪个 Page，这里当持久化该 Buffer 的时候，知道存储到磁盘的哪个位置。如果 postgresql 想支持跨平台，那么它不能依靠底层的原子操作，需要自身保证这些数据的正确写入，防止 part-write 问题（也就是当写入一个 Page 时机器断电了，可能造成 Page 只写了一部分）。
开发语言中，堆区和栈区的区别
最新发布
weixin_46282323的博客
11-14 565
栈区：自动分配与释放、存储局部变量、访问速度快、生命周期短、易导致栈溢出。堆区：手动管理内存、适用于大块数据、访问速度慢、生命周期长、易导致内存泄漏。栈区（Stack）：用于存储基本类型数据和函数调用栈，生命周期短、访问速度快，出作用域即释放。堆区（Heap）：用于存储引用类型数据，通过引用计数和标记清除来进行内存回收，适合存储动态数据。
响应拦截器的判断
2303_80137294的博客
11-10 550
res.status：用来判断 HTTP 请求的状态，告诉你请求是否成功（如 200 表示成功，500 表示服务器错误）。：是后端业务逻辑中的状态码，通常用来表示具体的操作是否成功或失败。根据不同的业务场景，后端可以自定义不同的code来传递详细的业务结果。
后端一次性返回数据，前端分页
qq_39307266的博客
11-14 206
vue 结合elementUI 分页组件，后端一次性返回数据，前端做分页。1.template中。js从后端获取总数据。
vxe-vxe-colgroup后端返回数据 对数据进行处理 动态合并分组表头(v-if控制表格渲染（数据请求完成后渲染）)
2301_76671906的博客
11-11 255
vxe-colgroup后端返回数据 对数据进行处理 动态合并分组表头(v-if控制表格渲染（数据请求完成后渲染）)
基于Java的药店管理系统
ZCY1998haonan的博客
11-14 517
药店管理系统 前后端分离 Java SpringBoot Vue 毕业设计
关于k8s中镜像的服务端口被拒绝的问题
politeboy的博客
11-14 235
Failed to connect to fd00::52f4 port 80: Connection refused
java itext后端生成pdf导出
到底要什么姿态，才不会显得我在使坏。
11-14 156
【代码】itext后端生成pdf导出。
C语言函数指针详解与应用
C语言中的函数指针是一个强大的工具，它能够提升程序的效率和灵活性，实现动态的数据通信和存储分配，以及构建复杂的程序结构。熟练掌握函数指针的使用技巧和方法，对于编写高质量的C语言程序至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值