一个简单的 C 程序，关于指针

（p[0]+1） 先看括号内的p[0]，即a+2，整个公式等于*（a+2+1），即。

a+3）等价于a[3]，即7。

q+2）也看括号q+2等价于p[2]p[2]是a的地址，所以**a是提取地址a中的数字，即1 1+7，当然是8。

在 C 语言中，如果单独使用数组地址，则后面不会跟方括号，方括号是指针。

而指针的加法和减法是地址的加法和减法。

因此，p[0]=a+2，a+2 是一个指针，加上 1 个点到 a+3，即值 7

至于 q+2，它指向 p[2]，所以指针 a，a 是数组的第一个，它是值 1，所以 7+1=8;

另外，写一点**也没关系，顺便说一句，做个广告，不介意！

p[3] 是一个由一位指针组成的数组，包含三个指针元素 int**q，因为定义是 *q &*q=&p;Q=&p 地址，（p[0]+1）=a+3，*（p[0]+1）=7;**q+2)=p[3]=1

1. A 实际上是指向整形 1 地址的指针，*a 是 a[0]; 同样，a+1 指向 3 的地址，*（a+1） 是 a[1]。

2. p[0] 是整数指针数组，p[0] 的内容是 a+2，所以 *p[0] 是 *（a+2），也就是 a[2]，就是 5而 p 是指向 a+2 指针的指针 （int**），即 *p 是 p[0]，等于 a+2，**p 是 5。

3. int** q=p，所以 q 指向 p[0]，q+2 指向 p[2]，*q+2） 是 p[2]，*q+2） 是 *p[2]，即 *a、a[0]、1

第四，p[0]是a+2，p[0]+1是a+3的几个，等于a[3]，7所以 1+7 是 8。

根据问题要求编写的程序如下（见图）。

让我告诉你一些关于它的信息。

如果你明白了，我希望你多加点，呵呵。

如果要应用整数变量 int a = 5;

所以 a 的值是 5，对吧？ 这很容易理解，所以如果你想知道这个 5 在内存中 a 指向的地址是什么。

然后，您需要获取 a 的地址并执行 &a 操作。 没错，&a 的返回值就是 a 所在的地址，如果我们想存储这个地址，我们需要一个指针来存储它，即 int* b = &a;

b 是指针。

其实，你注意到了吗？

int a = 5

int* b = &a

其实指针也是一个变量，但是我们的普通变量存储的是第二个指针的特殊变量的内存地址。 为了将这个特定变量与普通变量区分开来，让我们给它一个新名字：指针。

在了解了指针的实际含义之后，就没有好不好的问题了。 它的实际指针和它的直接变量之间根本没有区别。 那么为什么要使用指针呢？ 城市效率的主要问题。

如果没有，则设计一个函数。

struct get()

一个返回结构对象的函数，你知道，在C++中，这样的返回值是一个复制和传递的过程，也就是说，当你返回这个结构体时，程序会复制堆栈中的同一个结构对象，然后通过复制构造函数来接受变量来复制一个新的变量。 最后，程序正在解构这个临时程序。 如果结构很小，那就没什么问题了，但是如果它很大呢？

这种建设，一次破坏，将是浪费时间。 但是指针是不同的，不管你怎么得到它们，反正都是4个字节，和int一样，完全无法区分。

我希望你能理解我在说什么。

理解指针的关键在于理解内存分配。

1.指针的概念。

指针是一个特殊变量，它被解释为内存中的地址。 要了解指针，需要了解指针的四个方面：指针的类型、指针的类型、指针的值或指针指向的内存区域，以及指针本身所占据的内存区域。

让我们分别举例说明。

让我们先陈述一些指针，例如：

示例 1：1） int*ptr;

2)char*ptr;

3)int**ptr;

4)int(*ptr)[3];

5)int*(*ptr)[4];

1. 指针的类型。

从语法的角度来看，您只需从指针声明语句中删除指针名称，剩下的就是指针的类型。 这是指针本身所具有的类型。 让我们看一下示例 1 中每个指针的类型：

1)int*ptr;

指针的类型是 int*

2)char*ptr;

指针的类型为 char*

3)int**ptr;

指针的类型是 int*

4)int(*ptr)[3];

指针的类型为 int（*）3]。

5)int*(*ptr)[4];

指针的类型为 int*（*4）。

你觉得怎么样？ 找出指针的类型不是很容易吗？

2. 指针指向的类型。

使用指针访问指针指向的内存区域时，指针指向的类型决定了编译器将如何处理该区域的内容。

从语法上讲，您需要做的就是从指针语句中删除指针名称和名称左侧的指针声明符 *，剩下的就是指针指向的类型。 例如：

1)int*ptr;

指针指向的类型是 int

2)char*ptr;

指针指向的类型是 char

3)int**ptr;

指针指向的类型是 int*

4)int(*ptr)[3];

指针指向的类型是 int（）[3]。

5)int*(*ptr)[4];

指针指向的类型是 int*（）4]。

在指针的算术运算中，指针指向的类型起着很大的作用。 指针的类型（即指针本身的类型）和指针指向的类型是两个不同的概念。 随着你对C语言的熟悉程度越来越高，你会发现它与指针混合在一起"类型"这个概念分为："指针的类型"跟"指针指向的类型"两个概念是精通指针的关键点之一。

C 语言 071 指针的定义和使用。

你好！！

str1="1234";此时，数组的大小没有指示，这意味着字符：“1234”4个字符被分配给数组，注意系统会自动在字符串末尾添加一个结束标志，即'0'，输出时，编译器会判断是否遇到了结束标志。 如果没有，它将继续输出，直到它遇到结束符号。

和 char str1[4]="1234";这时，我将数组的大小定义为 4，所以此时的字符数是 4，所以我不能自动在字符串的末尾添加结束标志，所以输出在输出中"1234"之后会输出，直到遇到结束标志，所以末尾有一些乱码，解决办法可以是让数组的大小大于5。

str3="6789";这时定义了一个指针变量，系统会把字符串：“6789”放到内存的静态存储区（也就是一种内存，因为里面的值不能修改，所以是静态的），把字符串的第一个地址赋给指针变量str3，使指针变量指向字符串;

str3[1]='2';指示要修改静态存储的值，但存在无法修改的常量。 所以出了点问题。

char str1[4]="1234";

存储时： 1 2 3 4 0 所以这是一个溢出问题，你把数组改成str[5]就可以了。

str3 与 str1 和 str2 不同，它们都是在堆栈上分配的地址，但每个指针都被分配了一个地址，所以它是不同的，而 *str3 是一个字符串指针，定义时直接给出一个初始值，它的值不能再改变。

第一个 int *fun（int a， int b） 是一个指针函数，它返回指向整数的指针。

p=fun（a，b） 当参数 a=3，b=4 被传递到 fun 函数中时，因为 4>3，int *fun（inta，inb） 函数作为 q=&b 运行，并带回 main（） 函数 p=q=&b，最终结果输出 *p，即 b 4 的值。

如果 printf（"%d",b);其结果是 ：8。

定义函数时，参数表中的参数称为形式参数，简称表单参数。 参数必须是变量的名称。 例如，在此问题中，int *fun（int a，int b） 是 a， b 中的格式参数。

调用函数时，参数表中的参数称为实参数，简称实参数。 参数可以是表达式，但它们必须具有确定的值。 例如，在这个问题的 main（） 函数中，p=fun（a，b）; A 和 b 都是参数，它们都有特定的值。

你的fun函数是按值传递的，括号（int a，int b）等价于将a和b的副本传递给函数，所以main函数中的p指向b副本的地址，*p在你把b递增4后自然会保持不变。 如果将函数参数更改为 （int &a， int &b），则为 8。

关于参数和参数，你只需要记住，函数定义中出现的参数是参数，函数调用中出现的参数是参数。

因为执行是顺序执行，所以当它执行到 p=fun（a，b） 时，程序会转向被调用函数，也就是你之前定义的函数，此时 b 的值是 4，执行调用函数后，执行 b+=4，此时变量 b 的值变为 8， 但和前面的函数调用没有关系，不知道大家是否理解......

答：*p 在 main 函数中不是 b

#include

int* fun（int b） 其中 b 是一个参数，但它只是一个变量。

int main()

这是我对局部变量的正常理解。

也就是说，在局部变量的生命周期结束时，它应该被销毁。

但是，从上面的程序中可以看出，该函数在结束后不会立即被销毁。

奇怪，困惑......

#include

int* fun(int b)

int main()*/