结构体指针和函数（结构体指针和结构体变量在调用函数中的区别）

本文目录

• 结构体指针和结构体变量在调用函数中的区别
• 结构体内结构体指针是，在函数中对结构体指针进行操作值会发生变化
• c语言结构体，指针和函数编程
• 结构体指针与结构体变量用作函数参数时有什么区别，在用法上
• 指向结构体的指针作函数参数
• C 语言结构体为什么可以定义自己的指针，和函数指针 ，而不能定义自己类型的变量呢请教大拿
• C语言可以给结构体指针里的函数指针赋函数指针并调用结构体的函数指针吗
• 关于C语言结构体指针做函数形参的问题

结构体指针和结构体变量在调用函数中的区别

你的理解是对的。
形参是结构体变量的，你对该结构体的所有修改都不会影响到实参，因为形参是实参的一个完整拷贝。
形参是结构体指针的，你对该结构体的修改直接影响实参的结构体数据。因为形参和实参都指向同一个内存区块。注意：形参是一个指针，如果只改变指针本身，则不影响实参。

结构体内结构体指针是，在函数中对结构体指针进行操作值会发生变化

关键在于比较一下&a  和 &c的比较，看看两个是否同一个地址。

如果&a 和&c 不是同一个地址，则c指针指向的地址内容不会发生变化。

在test_pointer函数中，参数是intnode a  而非&a ，说明只是一个形式参数，调用时，是对c对象进行的一次拷贝构造，也就是说，在内存里面重新分配了一个c单元的拷贝。

通过c-》vul 指向的指针对s内存单元地址进行分配。

通过比较以下几个地址

1. &a  &c  比较一下两者是否同一内存区域

2. &s  p-》val【注意，是p-》val 而非  &p-》val】  比较。

3. &s-》data   &p-》val-》data   比较。

通过以上三个地址的比较，我想你应该会有一个明确的答案了。

c语言结构体，指针和函数编程

#include 《stdio.h》
#include 《stdlib.h》
struct student
{
long num;
char name;
int Eng,Math,Comp;
};
void Input( struct student *p, int n);
void Total1( struct student *p, int *psum, float *pave, int n);
void Sort( struct student *p, int *psum, float *pave, int n);
void Print( struct student *p, int *psum, float *pave, int n);
int main()
{
int n;
int *psum;
float *pave;
struct student *p;
scanf("%d",&n);
p=(struct student *) malloc (n*sizeof(struct student));
psum=(int *) malloc (n*sizeof(int));
pave=(float *) malloc (n*sizeof(float));
if (p!=NULL&&psum!=NULL&&pave!=NULL)
{
Input(p,n);
Total1(p,psum,pave,n);
Sort(p,psum,pave,n);
Print(p,psum,pave,n);
}
free(p);
free(psum);
free(pave);
return 0;
}
void Input( struct student *p, int n)
{
int i;
for (i=0;i《n;i++)
{
scanf("%ld%s%d%d%d",&(p+i)-》num,(p+i)-》name,&(p+i)-》Eng,&(p+i)-》Comp,&(p+i)-》Math);
}
}
void Total1( struct student *p, int *psum, float *pave, int n)
{
int i;
for (i=0;i《n;i++)
{
*(psum+i)=(p+i)-》Eng+(p+i)-》Comp+(p+i)-》Math;
*(pave+i)=(*(psum+i))*1.0/3;
}
}
void Sort( struct student *p, int *psum, float *pave, int n)
{
int i,j,k,temp1;
float temp2;
struct student temp3;
for (i=0;i《n;i++)
{
k=i;
for (j=i+1;j《n;j++)
{
if (*(psum+j)》=*(psum+k))
k=j;
}
if (k!=i)
{
temp1=*(psum+i);
*(psum+i)=*(psum+k);
*(psum+k)=temp1;
temp2=*(pave+i);
*(pave+i)=*(pave+k);
*(pave+k)=temp2;
temp3=*(p+i);
*(p+i)=*(p+k);
*(p+k)=temp3;
}
}
}
void Print( struct student *p, int *psum, float *pave, int n)
{
int i;
printf("Pos\tNum\tName\t\tEng\tCom\tMath\tSum\tAver\n");
for (i=0;i《n;i++)
{
printf("%d\t%ld\t%s\t\t%d\t%d\t%d\t%d\t%.0f\n",i+1,(p+i)-》num,(p+i)-》name,(p+i)-》Eng,(p+i)-》Comp,(p+i)-》Math,*(psum+i),*(pave+i));
}
}

结构体指针与结构体变量用作函数参数时有什么区别，在用法上

结构体指针与结构体变量用作函数参数区别：

（1）结构体指针作为函数参数时，调用时传递的是指向一个结构体变量的指针（即结构体变量的地址）；结构体变量作为函数参数时，调用时传递的结构体变量本身。

（2）以下代码显示了调用时的区别

#include 《stdio.h》

/* 定义结构体类型Point */

typedef struct {

int x;

int y;

} Point;    

void fun1(Point  point) {

point.x += 10;

point.y += 10;

}

void fun2(Point pPoint) {

pPoint-》x += 10;

pPoint-》y += 10;

}

void main( )

{

Point p;

p.x = 100;

p.y = 200;

/* 调用 fun1 */

fun1( p );

printf("x=%d, y=%d\", p.x, p.y);

/* 调用 fun2：取p的地址作为参数 */

fun2( &p);

printf("x=%d, y=%d\", p.x, p.y);

}

程序的输出为：

x=100, y=200

x=110, y=210

（3）观察上面程序运行的结果发现 fun1函数执行后，p并没发生变化；而调用fun2后，p却改变了。这是因为：调用fun1时，所传递的参数p被复制到调用堆栈中，fun1函数所操作是堆栈中的变量而不是原来的那个变量（main中的p）；另一方面，调用fun2时，传入的p的地址，fun2通过地址，修改了main中的变量p。这是结构体指针与结构体变量用作函数参数最大的区别。

一个结构体A，当它的指针作为参数传入函数func，那么在func中可以通过指针改变结构体的值，函数返回后，结构体的值被改变； 但是，当结构体变量作为参数传入函数func时，在func函数中即使对他进行了修改，当函数返回时，结构体本身并没有改变，因为修改的只是他的一个副本。

扩展资料

一、用结构体变量和指向结构体变量的指针构成链表

1、链表是一种常见的重要的数据结构。

2、链表有一个“头指针”变量，以head表示，它存放一个地址。该地址指向一个元素。

二、链表中的每一个元素称为“结点”，每个结点都应包括两个部分：

1、是用户需要用的实际数据，

2、是下一个结点的地址。

三、可以看到链表中各元素在内存中的存储单元可以是不连续的。要找某一元素，可以先找到上一个元素，根据它提供的下一元素地址找到下一个元素。

四、可以看到，这种链表的数据结构，必须利用结构体变量和指针才能实现。

五、可以声明一个结构体类型，包含两种成员，一种是用户需要用的实际数据，另一种是用来存放下一结点地址的指针变量。

指向结构体的指针作函数参数

很简单.
首先,我们定义一个指针是
类型
*
变量名，比如int
*pInt
=
NULL;
我们定义结构体指针也是一样的,
结构体名
*pStruct(C语言:struct
结构体名
*pStruct,
C++:结构体名
*pStruct,
struct一般可以省略),
比如:
#include
#include
struct
stStudent
{
char
szName;
int
nID;
};
void
Print(stStudent
*pStd)
{
printf("Name:%s\n",
pStd-》szName);
printf("ID:%d\n",
pStd-》nID);
}
void
InitStudent(stStudent
*pStd)
{
strcpy(pStd-》szName,
"CIW");
pStd-》nID
=
14;
}
int
main()
{
stStudent
stStd;
InitStudent(&stStd);
Print(&stStd);
return
0;
}
C语言请加struct.

C 语言结构体为什么可以定义自己的指针，和函数指针 ，而不能定义自己类型的变量呢请教大拿

因为自己类型的变量在这个类型中定义时，是不完整类型，除非你完成定义，不然不会知道这个类型的大小，而且本身嵌套本身，就等于是无穷递归的展开了。
但指针就不同了，C语言的指针大小是4个字节，他只是指向一个地址，和其他的全部无关，他不需要知道自己类型有多大，有怎样的结构什么的，这些都不是他该关心的，他只要指向一个正确的地址就OK了，这就是指针的职责。定义指针是确定，不会影响该类型的结构，也不会出现无穷递归展开，所以在结构体中定义自身指针是合法的。

C语言可以给结构体指针里的函数指针赋函数指针并调用结构体的函数指针吗

• 可以的。结构体里面可以有各种指针，没有限制。

• 这要看你所谓的"结构体指针里的函数指针"到底是啥了,如果是一个成员变量,其实和普通函数指针没有任何差别,当然可以使用了,用的方法都没差别

关于C语言结构体指针做函数形参的问题

*s表示变量m本身，对*s的赋值就是对m赋值，所以*s=a是正确的。

请注意，函数fun中的s变量是一个地址，只对该地址进行重新赋值，并不对其所指向的变量m造成影响。所以s=&a不改变main函数中m变量的值。

如果把*s=a，输出会是乱码。这具有很大的迷惑性，使人以为地址的赋值过程出现了问题。实际上，若把m改为全局变量（全局变量中字符串默认为空，int变量默认为0）：

#include《stdio.h》
#include《string.h》
#define N 10
typedef struct ss
{
 char num;
 int s;
}STU;
void fun(STU a,STU *s)
{
 int t,p=0;
 t=a.s;
 for(int i=1;i《N;i++)
 {
  if(t》a.s)
  {
   t=a.s;
            p=i;
  }
 }
 s=&a;     //这里是错误的语句
}
STU m;
void main()
{
STU a={
  {"A01",81},{"A02",81},{"A03",81},{"A04",81},{"A05",81},
  {"A06",81},{"A07",81},{"A08",61},{"A09",81},{"A010",81}
};
printf("the original data is :\n");
for(int i=0;i《N;i++)
{
  printf("NO=%s MARK=%d\n",a.s);
}
fun(a,&m);
printf("the lowest is %s  who’s score is %d\n",m.num,m.s);
}

输出的将会是the lowest is   who’s score is 0

这说明变量m的值并未改变过。

事实上，若非要使用&符号，正确的方法是使用“引用”：

#include《stdio.h》
#include《string.h》
#define N 10
typedef struct ss
{
char num;
int s;
}STU;
void fun(STU a,STU &s)
{
int t,p=0;
t=a.s;
for(int i=1;i《N;i++)
{
 if(t》a.s)
 {
  t=a.s;
           p=i;
 }
}
s=a;
}
void main()
{
STU a={
  {"A01",81},{"A02",81},{"A03",81},{"A04",81},{"A05",81},
  {"A06",81},{"A07",81},{"A08",61},{"A09",81},{"A010",81}
},m;
printf("the original data is :\n");
for(int i=0;i《N;i++)
{
  printf("NO=%s MARK=%d\n",a.s);
}
fun(a,m);
printf("the lowest is %s  who’s score is %d\n",m.num,m.s);
}

 这里&的意思是“引用”，你可以百度上搜索C++中&符号的两个意义。