p33 指针详解(1)(2)(3)(4)(5)

已于 2024-08-17 22:04:28 修改
阅读量770 收藏 29
点赞数 13
分类专栏： c语言学习专栏 文章标签： 面试 职场和发展
于 2024-08-01 21:17:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/monkeyhost/article/details/140840522
版权

指针的进阶

1.字符指针

void test(int arr[])
{
    int sz=sizeof(arr)/sizeof(arr[0]);
    printf("%d\n", sz);
}
int main()
{
    int arr[10] = {0};
    test(arr);

    return 0;
}

这个代码在64位计算机中是8/4=2

在32位计算机中的是4/4=1

int main()
{
	char ch='w';
	char *pc=&ch;
	printf("%c\n",*pc);

	return 0;
}

代码输出w

 int main()
{
    char arr[]="abcdef";
    char *pc=arr;
    printf("%s\n",arr);
    printf("%s\n",pc);
}

打印的都是abcdef

int main()
{
    char *p = "abcdef";
    printf("%s\n", p);
}

下面这个例子说明，*p字符串是不能够修改的。加上const就行了。

int main()
{
    const char *p="abcedf";
    //*p='W';
    printf("%s",p);
    return 0;
}

int main()
{
	char arr1[] = "abcdef";
	char arr2[] = "abcdef";
	char * p1 = "abcdef";
	char * p2 = "abcdef";
	if (arr1 == arr2)
	{

		printf("hehe\n");
	}
	else
	{
		printf("haha\n");
	}
	

	return 0;
}

haha

因为地址不相同

int main()
{
    char arr1[] = "abcdef";
    char arr2[] = "abcdef";
    char * p1 = "abcdef";
    char * p2 = "abcdef";
    if (p1==p2)
    {

        printf("hehe\n");
    }
    else
    {
        printf("haha\n");
    }
    

    return 0;
}

我条件改变了，p1==p2

直接就是hehe

因为字符串相同了 

2.数组指针

//数组指针-指针

int  main()

{

int *p=NULL;//p是整型指针-指向整形的指针-可以存放整型的地址

char *pc=NULL;//pc是字符的指针-指向字符的指针-可以存放字符的地址

//数组的指针-指向数组的指针  -存放数组的地址

//int arr[10]={0};

//arr-首元素地址

//&arr-数组的地址

int arr[10]={1,2,3,4,5,6,7,8,9,10};

int(*p)[10]=&arr;//数组的地址存起来

//上面的p就是数组指针

return 0;

}

int main()
{
    char *arr[5];
    char *(*pa)[5]=&arr;//【5】pa指向的数组是5个元素

//pa指向的数组的元素类型是char *
int arr2[10]={0};

int (*pa2)[10]=&arr2;

return 0;
}

int main()
{
	int arr[10]={1,2,3,4,5,6,7,8,9,10};
	int (*pa)[10]=&arr;
	int i=0;
	for(i=0;i<10;i++){
		printf("%d ",(*pa)[i]);
	}
	return 0;
}


int main()
{
	int arr[10]={1,2,3,4,5,6,7,8,9,10};
	int (*pa)[10]=&arr;
	int i=0;
	for(i=0;i<10;i++){
		printf("%d ",*(*pa+i));//*pa=arr
	}
	return 0;
}

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

void print1(int arr[3][5],int x,int y)
{
	int i=0;
	int j=0;
	for(i=0;i<x;i++)
	{
		for(j=0;j<y;j++)
		{
			printf("%d",arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[3][5]={{1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7}};

	print1(arr,3,5);//arr -数组名 -数组名就是首元素地址
}



//参数是数组的形式
void print1(int arr[3][5],int x,int y)
{
	int i=0;
	int j=0;
	for(i=0;i<x;i++)
	{
		for(j=0;j<y;j++)
		{
			printf("%d ",arr[i][j]);
		}
		printf("\n");
	}
}
//参数是指针的形式
void print2(int (*p)[5],int x,int y)
{
	int i=0;
	for(i=0;i<x;i++)
	{
		int j=0;
		for(j=0;j<y;j++)
		{
			//printf(	"%d ",*(*(p+i)+j));
              //printf("%d ",(*(p+i))[j]);
            //printf("%d",*(p[i]+j));
            //printf("%d",p[i][j]);

		}
		printf("\n");
	
	}
}
int main()
{
	int arr[3][5]={{1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7}};

	print1(arr,3,5);
	print2(arr,3,5);
	return 0;
}

int arr[5]; //arr是一个5个元素的整形数组

int *parr1[10];//parr1 是一个数组，数组有10个元素，每个元素的类型是int *,parr1是指针数组

int (*parr2)[10];//parr2是一个指针，该指针指向一个数组，数组有10个元素，每个元素的类型是int   parr2是数组指针

int (*parr3[10])[5];//parr3是一个数组，该数组有10个元素，每个元素是一个数组指针。

该数组指针指向的数组有5个元素。每个元素是int

前倾回顾：

int main()
{
    //字符指针
    char ch='w';
    char *p=&ch;
    const char *p2="abcdef";
    //指针数组-数组-存放指针的数组
    int *arr[10];
    char *ch[5];
    //数组指针
    //int *p3;//整型指针-指向整型的指针
    //char *p4;//字符指针-指向字符的
    int arr[5];//数组
    int (*pa)[5]=&arr2;//取出数组的地址,pa就是一个数组指针


    
    return 0;
}


 

3.指针数组

 //指针数组 是数组，用来存放指针的


int main(){
    int arr[10]={0};
    char ch[5]={0};
    int *parr[4];//存放整型指针的数组-指针数组
    char * pch[5];//存放字符指针的数组-指针数组

}

int main()
{
	int a = 10;
	int b=20;
	int c = 30;
	int d = 40;
	int *arr[4] = { &a,&b,&c,&d };
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d\n", *arr[i]);
	}	
	return 0;
}



int main()
{
	int arr1[] = {1,2,3,4,5};
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };
	int *parr[] = { arr1,arr2,arr3 };
	for (int i = 0; i < 3; i++)//3列
	{
		for (int j = 0; j < 5; j++)//5行
		{
			printf("%d ", parr[i][j]);//输出
		}
		}
		printf("\n");
	}
}

4.数组传参和指针传参

void test(int arr[])
{}
void test(int arr[10])
{}
void test(int *arr)
{}
void test2(int *arr[20])//ok
{}
void test2(int **arr)//ok
{}
int main()
{
    int arr[10]={0};
    int *arr2[20]={0};
    test(arr);
    test2(arr2);
}

void test(int arr[3][5])
{}
void test1(int arr[][5])
{}
//void test2(int arr[3][])//err
//{}
int main()
{
    int arr[3][5] = { 0 };
    test(arr);//二维数组传参
    test1(arr);
    //test2(arr);
}
 

//void test(int arr[3][5])
//{}
//void test1(int arr[][5])
//{}
void test2(int arr[3][])//err
{}
void test3(int *arr)//err
{}
void test4(int **arr)//err
{}
void test5(int (*arr)[5])
{}

int main()
{

    int arr[3][5] = { 0 };
    //test(arr);//二维数组传参
    //test1(arr);
    //test2(arr);
    //test3(arr);
    //test4(arr);
    test5(arr);
}

一级指针传参

void print(int *p,int sz) {
    for (int i = 0; i < sz; i++) {
        printf("%d ", *(p + i));
    }

}
int main() {
    int arr[] = { 1,2,3,4,5,6,7,8,9};
    int* p = arr;
    int sz=sizeof(arr)/sizeof(arr[0]);
    //一级指针p,传给函数
    print(p,sz);
    
    return 0;
}

当一个函数的参数部分为一级指针的时候，函数能接受什么参数？

void test1(int* p)
{}
void test2(char *p)
{}
int main()
{
    int a = 10;
    int *p1=&a;
    test1(&a);//ok
    test1(p1);//ok
    char ch='w';
    char *pc=&ch;
    test2(&ch);
    test2(pc);//ok
    return 0;
}

二级指针传参

void test(int** ptr)
{
    printf("%d\n", **ptr);
}
int main()
{
    int a = 10;
    int* p = &a;
    int** pp = &p;
    test(pp);
    test(&p);
    return 0;
}

void test(int **p)
{}
int main()
{
    int* ptr;
    int** pp = &ptr;
    test(pp);
    int* arr[10];
    test(arr);//指针数组
    return 0;
}

5.函数指针

//数组指针-是指向数组的指针

//函数指针-是指向函数的指针-存放函数地址的一个指针

int Add(int x, int y) {
    return x + y;
}
int main() {
    int a = 0;
    int b = 0;
    scanf("%d%d", &a, &b);
    int sum = Add(a, b);
    printf("%d\n", sum);
    return 0;
}

int Add(int x, int y) {
	return x + y;
}
int main() {
	int a = 10;
	int b = 20;
	int arr[10] = {0};
	//&arr;
	//arr;
	//printf("%d\n", Add(a,b));
        //&函数名和函数名都是函数的地址

	printf("%p\n", &Add);
	printf("%p\n", Add);
	return 0;
}

int Add(int x, int y) {
    return x + y;
}
int main() {
    /*int a = 10;
    int b = 20;
    int arr[10] = { 0 };
    int (*p)[10] = &arr;*/
    //&arr;
    //arr;
    //printf("%d\n", Add(a,b));

    //printf("%p\n", &Add);
    //printf("%p\n", Add);
    int (*pa)(int,int) = Add;
    printf("%d\n",(*pa)(2, 3));//5
    return 0;
}

结果是5

void Print(char *str)
{
	printf("%s\n",str);
}
int main()
{
	void (*p)(char *)=Print;
	(*p)("hello bit");
	return 0;
}

//代码1

(*(void (*)())0)();

void(*)()-函数指针类型

//把0强制类型转换成：void(*)()函数指针类型-0就是一个函数的地址

//调用0地址处的该函数

//代码2

void (*signal(int,void(*)(int)))(int);

//signal是一个函数声明
//signal函数的参数有2个，第一个是int。第二个是函数指针，该函数指针指向
//的函数的参数是int,返回类型是void
//signal函数的返回类型也是一个函数指针：该函数指针指向的函数的参数是int,
//返回类型是void
//
//void(*signal(int,void(*)(int)))(int);
//
简化
//typedef void(*pfun_t)(int);
//pfun_t signal(int ,pfun_t);
//
//typedef unsigned int uint;

int Add(int x,int y)
{
	return x+y;
}

int main()
{
	int a=10;
	int b=20;
	int (*pa)(int,int)=Add;
	printf("%d\n",pa(2,3));
	printf("%d\n",Add(2,3));
	//printf("%d\n",*pa(2,3));//err
	printf("%d\n",(pa)(2,3));
	return 0;
}

5

5

5

6.函数指针数组

数组是一个存放相同类型数据的存储空间，那我们已经学习了指针数组，比如：

int *arr[10];

//数组的每个元素是int*

那把函数的地址存发哦一个数组中，那这个数组就叫函数指针数组，那函数指针的数组如何定义呢？

int (*parr1[10])();

X int *parr2[10]();

X int (*)()parr3[10];

答案是:parr1 parr1先和[]结合，说明parr1是数组，数组的内容是什么呢？是int(*)()类型的函数指针。

函数指针数组的用途：转移表

例子：（计算器）

int Add(int x,int y)
{
	return x+y;
}
int Sub(int x,int y)
{
	return x-y;
}
int Mul(int x,int y)
{
	return x*y;
}
int Div(int x,int y)
{
	return x/y;
}
int main()
{
	//指针数组
	int *arr[5];
	//需要一个数组，这个数组可以存放4个函数的地址-函数指针的数组
	int (*pa)(int,int)=Add;//Sub/Mul/Div
	int (*parr[4])(int ,int)={Add,Sub,Mul,Div};
	int i=0;
	for(i=0;i<4;i++){
		printf("%d\n",parr[i](2,3));//
	}
	return 0;
}



void menu()
{
	printf("********************\n");
	printf("**1.add      2.sub**\n");
	printf("**3.mul      4.div**\n");
	printf("**  0.exit        **\n");
	printf("********************\n");

}

int Add(int x,int y)
{
	return x+y;
}
int Sub(int x,int y)
{
	return x-y;
}
int Mul(int x,int y)
{
	return x*y;
}
int Div(int x,int y)
{
	return x/y;
}
int main()
{
	int input =0;
	int x=0;
	int y=0;


	do
	{
		menu();
		printf("请选择:>");
		scanf("%d",&input);
		printf("请输入两个操作数:>");
		scanf("%d%d",&x,&y);
		switch(input)
		{
		case 1:
		printf(	"%d\n",Add(x,y));
			break;
		case 2:
		printf(	"%d\n",Sub(x,y));
			break;
		case 3:
		printf(	"%d\n",Mul(x,y));
			break;
		case 4:
		printf(	"%d\n",Div(x,y));
			break;
		case 0:
				printf("退出\n");
				break;
		default:
				printf("选择错误\n");
				break;

			}
		}while(input);
	


}

方法二： 

void menu()
{
	printf("********************\n");
	printf("**1.add      2.sub**\n");
	printf("**3.mul      4.div**\n");
	printf("** 5.Xor    0.exit**\n");
	printf("********************\n");

}

int Add(int x,int y)
{
	return x+y;
}
int Sub(int x,int y)
{
	return x-y;
}
int Mul(int x,int y)
{
	return x*y;
}
int Div(int x,int y)
{
	return x/y;
}
int Xor(int x,int y)
{
	return x^y;
}
int main()
{
	int input =0;
	int x=0;
	int y=0;
	//pfArr是一个函数指针组 -转移表
	int(*pfArr[])(int,int)={0,Add,Sub,Mul,Div,Xor};

	do
	{
		menu();
		printf("请选择:>");
		scanf("%d",&input);
		printf("请输入两个操作数:>");
		scanf("%d%d",&x,&y);
		switch(input)
		{
		case 1:
		printf(	"%d\n",Add(x,y));
			break;
		case 2:
		printf(	"%d\n",Sub(x,y));
			break;
		case 3:
		printf(	"%d\n",Mul(x,y));
			break;
		case 4:
		printf(	"%d\n",Div(x,y));
			break;
		case 0:
				printf("退出\n");
				break;
		default:
				printf("选择错误\n");
				break;

			}
		}while(input);
	


}

7.指向函数指针数组的指针

int main()
{
    int arr[10]={0};
    int (*p)[10]=&arr;//取出数组的地址
    int(*pf)(int ,int);//函数指针
    int (*pfArr[4])(int ,int);//pfArr是一个数组-函数指针的数组
    //ppfArr是一个指向[函数指针数组]的指针
    int (*(*ppfArr)[4])(int ,int )=&pfArr;
    //ppfArr是一个数组指针，指针指向的数组有4个元素
    //指向的数组的每个元素的类型是一个函数指针int(*)(int ,int)
    //
    return 0;
}

8.回调函数

为了除去冗余的函数，我们采用回调函数 

回调函数 

回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所向的函数时，我们就说这事回调函数。回调函数不是又该函数的实现方直接调用，而是在特定的时间或条件发生时由另外的一方调用，用于对改时间或条件进行响应。

void menu()
{
    printf("********************\n");
    printf("**1.add      2.sub**\n");
    printf("**3.mul      4.div**\n");
    printf("** 5.Xor    0.exit**\n");
    printf("********************\n");

}

int Add(int x,int y)
{
    return x+y;
}
int Sub(int x,int y)
{
    return x-y;
}
int Mul(int x,int y)
{
    return x*y;
}
int Div(int x,int y)
{
    return x/y;
}
int Xor(int x,int y)
{
    return x^y;
}
void Calc(int (*pf)(int,int)){
    int x=0;
    int y=0;
        printf("请输入两个操作数:>");
        scanf("%d%d",&x,&y);
        printf(    "%d\n",pf(x,y));

}
int main()
{
    int input =0;

    //pfArr是一个函数指针组 -转移表
    int(*pfArr[])(int,int)={0,Add,Sub,Mul,Div,Xor};

    do
    {
        menu();
        printf("请选择:>");
        scanf("%d",&input);
    
        switch(input)
        {
        case 1:
            Calc(Add);
            break;
        case 2:
            Calc(Sub);
            break;
        case 3:
            Calc(Mul);
            break;
        case 4:
        Calc(Div);
            break;
        case 0:
                printf("退出\n");
                break;
        default:
                printf("选择错误\n");
                break;

            }
        }while(input);
    


}

void print(char* str) {
	printf("hehe:%s\n", str);
}
void test(void(*p)(char*)) {
	printf("test\n");
	p("bit");
}
int main() {
	test(print);
	return 0;
}



int Add(int x, int y) {
	int sum = 0;
	sum = x + y;
	return sum;
}
int main() {
	//指针数组
	//int* arr[10];
	//数组指针
	//int (*pa)[10]= &arr;
	//函数指针
	int (*pAdd)(int ,int) = Add;//&Add
	int sum=(*pAdd)(1,2);
	printf("sum=%d\n", sum);
	return 0;
}

 

int Add(int x, int y) {
    int sum = 0;
    sum = x + y;
    return sum;
}
int main() {
    //指针数组
    //int* arr[10];
    //数组指针
    //int (*pa)[10]= &arr;
    //函数指针
    int (*pAdd)(int, int) = Add;//&Add
    //int sum = (*pAdd)(1, 2);
    int sum = pAdd(1, 2);
    printf("sum=%d\n", sum);
    return 0;
}

int Add(int x, int y) {
    int sum = 0;
    sum = x + y;
    return sum;
}
int main() {
    //指针数组
    //int* arr[10];
    //数组指针
    //int (*pa)[10]= &arr;
    //函数指针
    int (*pAdd)(int, int) = Add;//&Add
    //int sum = (*pAdd)(1, 2);
    //int sum = pAdd(1, 2);
    //printf("sum=%d\n", sum);
    // 函数指针的数组
    //int (*pArr[5])(int ,int );
    //指向函数指针数组的指针
    int (*(*ppArr)[5])(int, int) = &pArr;
    return 0;
}

void bubble_sort(int* p, int sz) {
	int i = 0;
	int j = 0;
	for (i = 0; i < sz - 1; i++) {
		for (j = 0; j < sz - i - 1; j++) {
			if (p[j] > p[j + 1]) {
				int temp = 0;
				temp = p[j];
				p[j] = p[j + 1];
				p[j + 1] = temp;
			}
		}
	}
}
int main()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	int sz=sizeof(arr) / sizeof(arr[0]);
	bubble_sort(arr, sz);
	int i = 0;
	for (i = 0; i < sz; i++) {
		printf("%d ", arr[i]);
	}

	return 0;	
}

 

9.指针和数组面试题的解析

靳向阳
关注
专栏目录
C语言指针详解(经典,非常详细)
liu100m的专栏
06-01 31万+
前言:复杂类型说明 要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,所以我总结了一下其原则:从变量名处起,根据运算符优先级结合,一步一步分析.下面让我们先从简单的类型开始慢慢分析吧: int p; //这是一个普通的整型变量 i...
C语言之指针详解
上善若泪
10-30 2万+
当初学C语言，指针是最头疼的地方，难以理解，不过时间长了就自然明白了通过指针，可以简化一些 C 编程任务的执行，还有一些任务，如动态内存分配，没有指针是无法执行的。每一个变量都有一个内存位置，每一个内存位置都定义了可使用&运算符访问的地址，它表示了在内存中的一个地址。用register修饰的变量是没法取到地址的，没有内存位置int * p;// 定义指针变量 p = & var_runoob;printf("var_runoob 变量的地址： %p\n" , p);return 0;
c++智能指针详解
bitcarmanlee的博客
05-18 3万+
1.什么是智能指针 从比较简单的层面来看，智能指针是RAII(Resource Acquisition Is Initialization，资源获取即初始化)机制对普通指针进行的一层封装。这样使得智能指针的行为动作像一个指针，本质上却是一个对象，这样可以方便管理一个对象的生命周期。 在c++中，智能指针一共定义了4种： auto_ptr、unique_ptr、shared_ptr 和 weak_ptr。其中，auto_ptr 在 C++11已被摒弃，在C++17中已经移除不可用。 2.原始指针的问题 原始指
指针数组与数组指针详解
men_wen的博客
09-28 25万+
指针数组与数组指针详解1.什么是指针数组和数组指针？ 指针数组：指针数组可以说成是”指针的数组”，首先这个变量是一个数组，其次，”指针”修饰这个数组，意思是说这个数组的所有元素都是指针类型，在32位系统中，指针占四个字节。 数组指针：数组指针可以说成是”数组的指针”，首先这个变量是一个指针，其次，”数组”修饰这个指针，意思是说这个指针存放着一个数组的首地址，或者说这个指针指向一个数组的首地址。 根
c语言指针用法详解，通俗易懂超详细！
嵌入式Linux
07-17 2万+
文章转自：无际单片机大家好，我是无际。今天给大家来讲解一下指针。我会由浅到深，最后结合实际应用讲解，让大家学会指针的同时，知道大佬们都用指针来干嘛！长文预警！全文大约5200多字，学指针看...
【C语言】让你不再害怕指针——C指针详解(经典,非常详细)
码农印象
03-23 13万+
因排版过于粗糙 学习详情转至 ： https://blog.csdn.net/qq_41035588/article/details/97010039 前言:复杂类型说明 要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,所以我总...
C语言——指针详解（必收藏）
weixin_59174190的博客
04-04 7万+
1.什么是指针？ 1.1概念 简单的来说，指针就是地址。我们口头上说的指针其实指的是指针变量。指针变量就是一个存放地址的变量。 1.2指针的大小 指针在32位机器下是4个字节，在64位机器下是8个字节。注：（指针的大小与类型无关） 1.3指针类型的作用 上面涉及到指针的大小与指针类型无关，那么指针类型的作用是什么呢？ 指针解引用访问，使用的访问权限是多少 话不多说，上图！ 当一个int* 的指针+1，跳过4个字节；当一个char* 的指针+1，跳过1...
C++指针详解
weixin_39640298的博客
12-08 10万+
概述 C/C++语言之所以强大，以及其自由性，很大部分体现在其灵活的指针运用上。因此，说指针是C/C++语言的灵魂一点都不为过。 有好的一面，必然会有坏的一面，指针的灵活导致了它的难以控制，所以C/C++程序员的很多bug是基于指针问题上的。今天就对指针进行详细的整理。 1、指针是什么？ 指针是“指向（point to）”另外一种类型的复合类型。复合类型是指基于其它类型定义的类型。 理解指针，先从...
C++ 智能指针 - 全部用法详解
cpp_learner的博客
08-02 8万+
血的教训？不学智能指针，本人丢了一份工作。
让你不再害怕指针——C指针详解(经典,非常详细)
热门推荐
程序老兵的博客
04-12 49万+
前言:复杂类型说明     要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,所以我总结了一下其原则:从变量名处起,根据运算符优先级结合,一步一步分析.下面让我们先从简单的类型开始慢慢分析吧: int p; //这是一个普通的整型变量 int
C语言指针详解 C语言指针详解
10-04
例如，`int (*p)[3]`中的`()`使得`*`先于`[]`结合，因此`p`是一个指针，它指向一个包含三个`int`的数组。 对于指针的类型和所指向的类型，我们可以这样区分： - **指针的类型**：指针变量本身的类型，即声明指针时...
C指针详解 经典 非常详细.pdf
01-13
"C指针详解" 在学习C语言指针时，我们需要了解指针的类型、指针所指向的类型、指针的值、指针本身所占据的内存区等四个方面的内容。 首先，让我们了解指针的类型。从语法的角度看，只需把指针声明语句里的指针名字...
C语言指针详解及用法示例
01-21
 首先我们可以理解 int* 这个是要定义一个指针p，然后因为这个指针存储的是地址所以要对a取地址(&)将值赋给指针p，也就是说这个指针p指向a。  很多新手都会对这两种定义方法感到迷惑，其实他俩的意思是一样的。第...
C语言中指针 int *p=0;和int *p;*p=0;和”&“的关系和区别详解
08-25
当你尝试打印`*p`（解引用`p`）时，由于`p`是空指针，程序将尝试访问无效的内存地址，从而导致运行时错误，如段错误。 另一方面，`int *p;*p=0;` 首先声明了一个未初始化的`int`指针`p`。在C语言中，未初始化的指针...
4399 C++面试题及参考答案
最新发布
大模型大数据攻城狮的专栏
11-13 395
C 和 C++ 的区别是什么？ C 语言是一种过程式编程语言，而 C++ 是在 C 语言基础上发展而来的面向对象编程语言。 从语法层面来看，C 语言没有类和对象的概念。 而在 C++ 中可以定义类，把数据和操作数据的函数封装在一起，像这样： class Point { public: int x; int y; Point(int a, int b) { x = a; y = b; } }; 在内存管理方面
C++ 内存分布及 new , delete 分配问题( ~~~ 面试重要 ~~~)
GAOSHOUCYUYAN的博客
11-10 786
本篇文章笔者将会对 C++ 中的内存问题简单的讲解 , 同时对 new , delete 的面试题进行重点讲解.以上就是本篇的内容 , 希望读者认真领会.
前端基础面试题·第四篇——Vue（其三）
2301_76380626的博客
11-09 851
Vue中组件定义式可以为其添加一个name属性，这个属性是组件的别名。当时组件被渲染时，Vue DevTools 会显示组件的名称，方便开发者调试，增强调试体验。当组件需要在内部调用渲染自己本身时，需要通过name属性来指定组件名称，否则Vue会报错。给组件命名后，我们可以通过全局注册，在全应用范围内使用该组件。方便了组件的使用，提高了组件复用性。使用keep-alive包裹动态组件时，可以通过include和exclude属性来指定哪些组件需要缓存，哪些组件不需要缓存。
微服务架构面试内容整理-监控与追踪-Zipkin
不务正业的猿
11-11 149
通过为每个请求生成 Trace ID 并跟踪其在各个微服务之间的传播情况，Zipkin 能够帮助开发者清晰地理解系统的调用链路，找出性能瓶颈和问题点，从而提高系统的稳定性和用户体验。当一个请求在多个微服务之间传播时，Zipkin 会通过请求头（HTTP Headers）传递 Trace ID 和 Span ID，从而确保所有服务的追踪数据能够关联起来。微服务监控：在微服务架构中，Zipkin 可以帮助开发者理解请求在不同服务之间的流转情况，监控微服务之间的交互。
指针详解：作为函数参数的指针变量
int num1 = 5, num2 = 3; sort_descending(&num1, &num2); ``` 经过调用后，`num1`和`num2`的值将会互换，因为函数通过指针直接修改了它们的值。 指针在处理复杂数据结构如数组、字符串以及动态内存分配时尤其有用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

靳向阳

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值