精华内容
下载资源
问答
  • 指针 - 为什么C中的箭头( - >)运算符存在?
    2021-05-18 12:33:21

    我将您的问题解释为两个问题:1)为什么.甚至存在,以及2)为什么.不会自动取消引用指针。 这两个问题的答案都有历史根源。

    为什么.甚至存在?

    在C语言的最初版本之一(我将其称为“C参考手册”的CRM,与1975年5月的第6版Unix一起提供)中,运算符.具有非常独特的含义,而不是.和c组合的同义词

    CRM描述的C语言在很多方面与现代C语言截然不同。 在CRM结构中,成员实现了字节偏移的全局概念,可以将其添加到任何地址值,而不受类型限制。即 所有结构成员的所有名称都具有独立的全局含义(因此,必须是唯一的)。 例如,您可以声明

    struct S {

    int a;

    int b;

    };

    并且名称.将代表偏移0,而名称.代表偏移2(假设c类型的大小为2且没有填充)。 语言要求翻译单元中所有结构的所有成员都具有唯一的名称或代表相同的偏移值。 例如。 在同一个翻译单元中,您还可以声明

    struct X {

    int a;

    int x;

    };

    那没关系,因为名称.一直代表偏移0.但是这个额外的声明

    struct Y {

    int b;

    int a;

    };

    将正式无效,因为它试图将.“重新定义”为偏移量2和.作为偏移量0。

    这就是.运算符的用武之地。由于每个结构成员名称都有自己的自足全局含义,语言支持这些表达式

    int i = 5;

    i->b = 42; /* Write 42 into `int` at address 7 */

    100->a = 0; /* Write 0 into `int` at address 100 */

    编译器将第一个赋值解释为“获取地址.,向其添加偏移量.并将c分配给结果地址处的struct T值”。即 以上将在地址c分配b至c值。请注意,->的这种使用并不关心左侧的表达式类型。 左侧被解释为右值数字地址(无论是指针还是整数)。

    .和.组合无法实现这种技巧。 你做不到

    (*i).b = 42;

    因为.已经是一个无效的表达式。 .运算符由于与c分开,因此对其操作数施加了更严格的类型要求。 为了提供解决此限制的能力,CRM引入了struct T运算符,该运算符独立于左侧操作数的类型。

    正如Keith在评论中指出的那样,.与. + c组合之间的差异是CRM在7.1.8中所称的“放宽要求”:除了放宽.指针类型的要求外,表达式 .完全相同于c

    后来,在K& R C中,最初在CRM中描述的许多特征被显着地重新设计。 完全删除了“struct member as global offset identifier”的想法。 并且.运营商的功能与.和c组合的功能完全相同。

    为什么.无法自动取消引用指针?

    同样,在该语言的CRM版本中,.运算符的左操作数必须是左值。 这是对该操作数施加的唯一要求(这就是它与.不同的原因,如上所述)。 请注意,CRM不要求c的左操作数具有结构类型。 它只需要它是一个左值,任何左值。 这意味着在C的CRM版本中,您可以编写这样的代码

    struct S { int a, b; };

    struct T { float x, y, z; };

    struct T c;

    c.b = 55;

    在这种情况下,编译器会将.写入.值,该值位于连续内存块(位于c)的字节偏移量2处,即使类型struct T没有名为b的字段。编译器根本不关心c的实际类型。 所有它关心的是c是一个左值:某种可写的内存块。

    现在请注意,如果你这样做了

    S *s;

    ...

    s.b = 42;

    代码被认为是有效的(因为.也是一个左值),编译器只是尝试将数据写入指针.本身,在字节偏移量2.不用说,这样的事情很容易导致内存溢出,但是 这种语言并不涉及这种问题。

    即 在该语言版本中,您提出的关于为指针类型重载运算符.的想法不起作用:运算符.在与指针一起使用时已经具有非常具体的含义(使用左值指针或任何左值)。 毫无疑问,这是非常奇怪的功能。 但它当时就在那里。

    当然,这种奇怪的功能并不是在C-K& R C的重新设计版本中引入重载.运算符(如你所建议的)的一个非常强大的原因。但它还没有完成。 也许当时有一些必须支持的CRM版C编写的遗留代码。

    (1975 C参考手册的URL可能不稳定。另一个副本,可能有一些细微差别,在这里。)

    更多相关内容
  • c语言指针基础知识

    2021-05-18 12:33:41
    c语言指针基础知识将指针和普通变量进行比较,将有助于您理解指针。所谓“普通变量”就是存储器中能够保存数值的一个位置。例如,当您声明变量i为一个整数时,四个字节的存储空间就为它预留出来了。程序中用i表示...

    c语言之指针基础知识

    将指针和普通变量进行比较,将有助于您理解指针。所谓“普通变量”就是存储器中能够保存数值的一个位置。例如,当您声明变量i为一个整数时,四个字节的存储空间就为它预留出来了。程序中用i表示那个预留出的位置。在机器的层面上看,这个位置具有一个内存地址。从这个地址开始的四个字节对您(程序员)来说就是变量i,它们可以保存一个整数。

    de570858d0ea4535c39434624cb9408d.png

    c语言之指针基础知识

    指针就不同了。指针是指向另一个变量的变量。意思是一个指针保存的是另一个变量的内存地址。换句话说,指针保存的并不是普通意义上的数值,而是另一个变量的'地址值。一个指针保存了另一个变量的地址值,就说这个指针“指向”了那个变量。

    因为指针保存了地址而不是数值,所以它有两个部分。指针本身保存一个地址,这个地址又指向一个数值,即:指针本身和被指向的数值两部分。这个概念开始可能有些不好理解,而一旦掌握将是极有裨益的。

    下面的例子显示了一个典型的指针:

    #include

    int main()

    {

    int i,j;

    int *p;

    p=&i;

    *p=5;

    j=i;

    printf("%d %d %d

    ", i, j, *p);

    return 0;

    }

    程序的第一行声明了两个普通的整型变量i和j。int *p这行声明了一个名为p的指针。它告诉编译器,所声明的变量p是一个指向整数的指针。*表示声明的是指针而不是普通变量。您可以创建任何类型的指针:float,结构体,char等等。只要用*指出您要的是指针而非普通变量即可。

    p=&i 这行您肯定还没见过。C语言中, 这个表达式的意思就是“将i的地址赋值给p。”这条语句一经执行,p就“指向”了i。而此前p的内容是一个未知的随机地址,直接使用的话很可能会导致程序错误或类似的程序崩溃。

    画图是观察程序运行过程的好方法。声明i、j和p后,程序的状态是这个样子:

    上图中的三个变量i、j和p都被声明过了,但还没有初始化。所以将两个整型变量以含有问号的方框表示——程序执行到这一步时它们的内容可以是任何值。将指针以圆圈表示,以区别于保存数值的一般变量,随意的几个箭头表示它现在可能指向任何一个位置。

    执行了p=&i这行后,p被初始化为指向i,像这样:

    p指向i之后,i代表的内存位置就有了两个名字。它除了叫做i,现在还叫做*p。这就是为什么说C中的指针变量有两个部分:p是容纳地址的位置,而*p是地址指向的位置。因此*p=5的意思是将p指向的位置的值设为5,像这样:

    因为*p和i代表同一位置,i的值自然也就变成了5。于是j=i;将j也设为5,printf语句的输出就是5 5 5。

    指针的主要特性是它天生具有两部分。指针本身除了保存地址,还指向某种类型的值,而这个值的地址正是指针保存的那个。在上面的例子中,指针本身是p,它指向的值是*p。

    展开全文
  • C语言 结构体和指针详解及简单示例

    千次阅读 2021-05-20 02:49:06
    指针也可以指向一个结构体,定义的形式一般为:struct 结构体名 *变量名;下面是一个定义结构体指针的实例:struct stu{char *name; //姓名int num; //学号int age; //年龄char group; //所在小组float score; //成绩...

    指针也可以指向一个结构体,定义的形式一般为:

    struct 结构体名 *变量名;

    下面是一个定义结构体指针的实例:

    struct stu{

    char *name; //姓名

    int num; //学号

    int age; //年龄

    char group; //所在小组

    float score; //成绩

    } stu1 = { "Tom", 12, 18, 'A', 136.5 };

    //结构体指针

    struct stu *pstu = &stu1;

    也可以在定义结构体的同时定义结构体指针:

    struct stu{

    char *name; //姓名

    int num; //学号

    int age; //年龄

    char group; //所在小组

    float score; //成绩

    } stu1 = { "Tom", 12, 18, 'A', 136.5 }, *pstu = &stu1;

    注意,结构体变量名和数组名不同,数组名在表达式中会被转换为数组指针,而结构体变量名不会,无论在任何表达式中它表示的都是整个集合本身,要想取得结构体变量的地址,必须在前面加&,所以给 pstu 赋值只能写作:

    struct stu *pstu = &stu1;

    而不能写作:

    struct stu *pstu = stu1;

    还应该注意,结构体和结构体变量是两个不同的概念:结构体是一种数据类型,是一种创建变量的模板,编译器不会为它分配内存空间,就像 int、float、char 这些关键字本身不占用内存一样;结构体变量才包含实实在在的数据,才需要内存来存储。下面的写法是错误的,不可能去取一个结构体名的地址,也不能将它赋值给其他变量:

    struct stu *pstu = &stu;

    struct stu *pstu = stu;

    获取结构体成员

    通过结构体指针可以获取结构体成员,一般形式为:

    (*pointer).memberName

    或者:

    pointer->memberName

    第一种写法中,.的优先级高于*,(*pointer)两边的括号不能少。如果去掉括号写作*pointer.memberName,那么就等效于*(pointer.numberName),这样意义就完全不对了。

    第二种写法中,->是一个新的运算符,习惯称它为“箭头”,有了它,可以通过结构体指针直接取得结构体成员;这也是->在C语言中的唯一用途。

    上面的两种写法是等效的,我们通常采用后面的写法,这样更加直观。

    【示例】结构体指针的使用。

    #include

    int main(){

    struct{

    char *name; //姓名

    int num; //学号

    int age; //年龄

    char group; //所在小组

    float score; //成绩

    } stu1 = { "Tom", 12, 18, 'A', 136.5 }, *pstu = &stu1;

    //读取结构体成员的值

    printf("%s的学号是%d,年龄是%d,在%c组,今年的成绩是%.1f!\n", (*pstu).name, (*pstu).num, (*pstu).age, (*pstu).group, (*pstu).score);

    printf("%s的学号是%d,年龄是%d,在%c组,今年的成绩是%.1f!\n", pstu->name, pstu->num, pstu->age, pstu->group, pstu->score);

    return 0;

    }

    运行结果:

    Tom的学号是12,年龄是18,在A组,今年的成绩是136.5!

    Tom的学号是12,年龄是18,在A组,今年的成绩是136.5!

    【示例】结构体数组指针的使用。

    #include

    struct stu{

    char *name; //姓名

    int num; //学号

    int age; //年龄

    char group; //所在小组

    float score; //成绩

    }stus[] = {

    {"Zhou ping", 5, 18, 'C', 145.0},

    {"Zhang ping", 4, 19, 'A', 130.5},

    {"Liu fang", 1, 18, 'A', 148.5},

    {"Cheng ling", 2, 17, 'F', 139.0},

    {"Wang ming", 3, 17, 'B', 144.5}

    }, *ps;

    int main(){

    //求数组长度

    int len = sizeof(stus) / sizeof(struct stu);

    printf("Name\t\tNum\tAge\tGroup\tScore\t\n");

    for(ps=stus; ps

    printf("%s\t%d\t%d\t%c\t%.1f\n", ps->name, ps->num, ps->age, ps->group, ps->score);

    }

    return 0;

    }

    运行结果:

    Name            Num     Age     Group   Score

    Zhou ping       5       18      C       145.0

    Zhang ping      4       19      A       130.5

    Liu fang        1       18      A       148.5

    Cheng ling      2       17      F       139.0

    Wang ming       3       17      B       144.5

    结构体指针作为函数参数

    结构体变量名代表的是整个集合本身,作为函数参数时传递的整个集合,也就是所有成员,而不是像数组一样被编译器转换成一个指针。如果结构体成员较多,尤其是成员为数组时,传送的时间和空间开销会很大,影响程序的运行效率。所以最好的办法就是使用结构体指针,这时由实参传向形参的只是一个地址,非常快速。

    【示例】计算全班学生的总成绩、平均成绩和以及 140 分以下的人数。

    #include

    struct stu{

    char *name; //姓名

    int num; //学号

    int age; //年龄

    char group; //所在小组

    float score; //成绩

    }stus[] = {

    {"Li ping", 5, 18, 'C', 145.0},

    {"Zhang ping", 4, 19, 'A', 130.5},

    {"He fang", 1, 18, 'A', 148.5},

    {"Cheng ling", 2, 17, 'F', 139.0},

    {"Wang ming", 3, 17, 'B', 144.5}

    };

    void average(struct stu *ps, int len);

    int main(){

    int len = sizeof(stus) / sizeof(struct stu);

    average(stus, len);

    return 0;

    }

    void average(struct stu *ps, int len){

    int i, num_140 = 0;

    float average, sum = 0;

    for(i=0; i

    sum += (ps + i) -> score;

    if((ps + i)->score < 140) num_140++;

    }

    printf("sum=%.2f\naverage=%.2f\nnum_140=%d\n", sum, sum/5, num_140);

    }

    运行结果:

    sum=707.50

    average=141.50

    num_140=2

    以上就是对结构体和指针的资料整理,后续继续补充相关资料,谢谢大家对本站的支持!

    展开全文
  • C语言指针,便于理解

    千次阅读 2021-05-25 06:40:01
    一、指针变量定义C语言有两种变量:其中变量(普通变量)存储内容值;地址变量(指针变量)存储地址值。1、定义的格式:类型名 *指针变量名;如:int a,b,*p1,*p2;float x,y,*p3,*p4;chars,*p5,*p6;注:(1)...

    一、指针变量定义

    C语言有两种变量:

    其中变量(普通变量)存储内容值;地址变量(指针变量)存储地址值。

    1、定义的格式:

    类型名 *指针变量名;

    如:

    int a,b,*p1,*p2;

    float x,y,*p3,*p4;

    chars,*p5,*p6;

    注:

    (1)定义变量(普通变量、指针变量)都必须在前面有类型名。

    (2)在定义指针变量时,指针变量名前的“*”表示现定义的是一个指针类型的变量。星号并不是指针变量名的一部分,只有一个标志。

    (3)指针变景专口用来存地址,禁止将一个整型值直接t给一不着变量。

    int a,b,*p;

    a=1000;

    b=2000;

    p=4000;//错误只能存地址值

    2、指针变量的引用

    “&”取地址运算符,通过&运算符可以取出普通变量的地址。

    “”指针运算符,可以取出指针变量所指向的普通变量的值,(间接引用普通量)

    *指针变量名

    如:

    int a,b=20,c=30,d=40,*p;

    p=&d;

    a=*p;a=d;

    指针方法:

    口诀:内容变量画房子,指针变量画指向,定义也要初始化,

    口诀:地址变量得地址,得谁地址指向谁,有*为内容值,不是读就是写,=号左边是写操作

    画图:数组,static,指针,链表,文件

    注:

    (1)可以通过赋值使一个指针变量“指向”某一普通变量(指针变量=&普通变量)。

    (2)在C语言中正确的做法是先让指针变量指向一个确定的存储单元后,再通过该指针变量引用它所指向的存储单元,如:

    int *p;//p的"房子"是随机的,指针是任意指的,如果指针指向系统区,则代价极高

    *p=200;危险!//因此在C语言中指针必须定义且初始化

    (3)变量名(普通变量、指针变量)都表示其存储单元内的值。

    pl=p2;/*pl指向了p2所指向的单元*/

    读出p2的内容值写到p1的"房子"里

    (4)若指针变量p指向变量a,即将变量a的地址赋给了指针变量p。

    如:int a=20,*p=&a;则有下列结果(等价表):

    A、*p<=>a

    B、p<=>&a

    C、&*p<=>&a<=>p

    D、*&a<=>*p<=>a

    E、(*p)++ a++都是给变量a的值加1。

    (*p)-- a--

    ++(*p) ++a ++*p

    --(*p) --a --*p

    (5)所有的指针变量在内存中分配的字节数相同。sizcof()

    int *p1;

    float *p2;

    double *p3;

    指针变量永远占两个字节(地址),前面类型表示的是该指针指向的内容值的类型

    例1:

    请输出下列程序的结果

    void fun(int*x,int*y)

    {printf("%d %d",*x,*y);

    *x=3;

    *y=4;

    }

    main()

    {int x=1,y=2;

    fun(&y,&x);

    printf("d% d%",x,y);

    }

    输出结果:2 14 3

    例2:

    #include请输出下列程序的结果

    void swap(int*pl,int*p2)

    {int temp;

    temp=*p1;

    *p1=*p2;

    *p2=temp;}

    main()

    {

    int a,b;

    int *p1=&a,*p2=&b;

    scanf("%d%d",pl,p2);

    swap(pl,p2);

    printf("%d,%d",*pl,*p2);

    }

    键盘输入2 5

    输出结果:5,2

    改动后:

    #include请输出下列程序的结果

    void swap(int*pl,int*p2)

    {int *temp;

    temp=pl;

    p1=p2;

    p2=temp;

    }

    main()

    {int a,b;

    int*p1=&a,*p2=&b;

    scanf("%d%d",pl,p2);

    swap(p1,p2);

    printf("%d,%d",*p1,*p2);

    }

    键盘输入:2 5

    输出结果为: 2,5

    例3:

    #include请输出下列程序的结果

    void swap(int*pl,int*p2)

    {int *temp;

    *temp=*pl;

    *p1=*p2;

    *p2=*temp;}

    main()

    {int a,b;

    int *p1=&a,*p2=&b;

    scanf("%d%d",pl,p2);

    swap(pl,p2);

    printf(%d,%d",*p1,*p2);

    }

    键盘输入:2 5

    结果:是5,2吗?错误!会报错哦,指针变量不能任意指,必须初始化程序中temp没有初始化所以很危险哦

    二、一维数组与指针变量

    说明:(1)

    int fun(int a[10])<=>int fun(int*a)<=>int fun(int a[])

    若数组做为形参,则将数组名做指针变量来处理。

    指向数组的指针变量

    1、指向数组元素的指针变量

    由于数组元素与普通一样,所以定义指向数组元素的指针变量与定义指向普通变量的指针变量完全一样

    如:

    int s[10],a,b;

    int b[3][6];

    int*p;

    p=&a;

    p=&s[2];

    p=&b[2][4];

    2、指向一维数组的指针变量

    注:数组a[]

    (1)在C语言中规定:数组名a代表数组的首地址,而且是一个地址常量,且a<=>&a[0]

    如:

    int a[10];intp;P=a;<=>P=&a[0];

    (2)当指针变量指向数组中的某一个元素时,指针变量加1后指向数组的下一个元素,指针变量减1时指向数组中前一个元素。

    如:

    float a[10];floatp;p=&a[4];则p-3指向?---->a[1]

    (3)

    int a[N],*p=a;

    p+i a+i &a[i] 地址三者相互等价

    *(p+i) *(a+i) a[i] p[i] 元素四等价

    当指针变量指向数组时,下标运算符(一级) ([])用于数组也可用于指针变量后

    a)*(p+i)*(a+i)a[i] p[i]

    b)p++、++p、p+=1、p=p+1

    c)p--、--p、p-=1、p=p-1

    d)*p++*(p++) *p-- *(p--)

    e)*++p *(++p) *--p *(--p)

    f)(*p)++ ++(*p)++*p

    g)(*p)-- --(*p)--*p

    如:

    若有定义:

    int b[5]={10,30,20,15,40};

    int*q=b+2;

    则:

    ++二级从右向左运算

    q++表达式的值?,同时q指向了?----->(q++)--->20,b[3]

    ++q表达式的值?,同时q指向了?----->(++q)---->15,b[3]

    (q)++表达式的值?同时q指向了?21,b[2]

    ++(q)表达式的值?同时q指向了?21,b[2]

    例:

    举例指针在数组中的使用:

    main()

    {int*p,a[3],I;

    p=a;

    for(i=0:i<3;i++) //for(i=0;i<3;i++)

    scnaf("%d",p++); // scanf("%d",&a[i]);

    printf("\n\n");

    for(p=&a[0];p

    printf("%d",*p++); //printf("%d",a[i]);

    }

    (4)若两个指针变量指向同一个数组,则这两个指针变量可以进行大小比较如:

    char s[10];charpl=s+3,p2=&s[7];

    则:

    pl>p2=>0 pl1

    p1-p2=>-4 p2-p1=>4

    (5)在形参中的数组实际上是一个指针变量,并不是真正的数组,因为该“数组名”的值是可以改变的,而真正的数组名的值是不能改变的。

    (6)若形参是数组或指针变量,则在函数中可以通过该形参改变实参的值

    三、多维数组与指针变量

    如:int a[3][4];

    a+1是跳过一行。因为二维数组名是行指针,加1是跳过一行不是一个元素切记:

    ①只有列指针才是“真正”指向元素。即指向某一个元素的存储单元

    ②一维数组名表示的是列指针;二维数组名表示的是行指针。

    注:若a是一个二维数组,则有:

    (1)a+i是行指针,即指向的是一整行。若对它加1则指向下一行

    (2)*(a+i)和a[i]一样,都是一个列指针即指向的是一个元素,

    (3)*(a+i)+j和a[i]+j一样,都表示元素a[i][j]的地址。即与&a[i][j]等价

    *(a+i)+j a[i]+j &a[i][j]地址三等价

    (4)*(*(a+i)+j)、*(a[]j)、(*(a+i))[j]和a[i][j]一样,都表示(元素四等价)

    若有以下定义:

    int w[2][3];

    则对w数组元素非法引用是:E

    A、*(w[0]+2)B、*(w+1)[2]C、w[0][0]D、*(w[1]+2)E、w[l]+2

    1、指向多维数组元素的指针变量

    如:

    int a[31[4];

    int*p=&a[0][3];

    则:

    p+1指向元素a[1][0];

    p+4指向元素a[1][3]

    p-2指向元素a[0][1]

    常用于取二维数组a元素地址的方式:

    &a[i][j]、a[i]+j、*(a+i)+j

    例:

    main()

    { int a[3][3]={1,2,3,4,5,6,7,8,9},*p;

    for(p=a[0];p

    展开全文
  • C语言中,调用成员变量用点还是用箭头,取决于当前的ID是指针还是结构体本身。如:typedefstruct{floatheight;floatweight;}Person;intmain(intargc,char*argv[]){Personjiushen;Person*lengleng=(Person*)malloc...
  • 原标题:C语言指针学习的4个难点都说指针C语言的灵魂,是重点也是难点,C语言指针学习难在哪里?即使了解了C语音指针是什么,可能你们会依然感到难学,那么它究竟难学在哪里呢?以下试着从4个方面聊聊它难学在...
  • C语言实验指针

    2021-09-14 10:16:38
    指针 实验目的 1.掌握指针的概念、指针变量的定义及初始化 2.掌握指针作为函数参数的方法 3.掌握函数的指针及其应用 实验条件: PC 计算机,Windows7 或 Windows10 操作系统,Office2010 及以上版本, Dev-C++5.11 ...
  • C语言指针详解

    2021-09-26 12:07:49
    C语言里,变量存放在内存中,而内存其实就是一组有序字节组成的数组,每个字节有唯一的内存地址。CPU 通过内存寻址对存储在内存中的某个指定数据对象的地址进行定位。这里,数据对象是指存储在内存中的一个指定数据...
  • c是一种自由度非常高的语言,在编程过程需要考虑各种优先级的划分,本文分享一下有关指针和自增(自减)符号的优先级划分。 首先我们先确定一点,指针和自增符号的优先级是一样的,且运算顺序都是自右向左的,所以...
  • C语言篇:指针

    2021-05-21 12:04:33
    指针C语言的灵魂。并不是所有的高级语言都具有指针,C++虽然有指针,但是从设计上希望程序员尽可能少得使用指针,C则不然。C是追求效率的,所以有时不得不把安全问题交给程序员。正是指针赋予了C“直接操作内存”...
  • 地址变量得地址,得谁地址指向谁和指针相关的问题要画图: 内容变量画房子,指针箭头---->口----------------------------------------------------和指针相关的两个特殊运算符:一、"&" 取地址运算符,...
  • C语言结构体指针的定义形式一般为: struct 结构体名 *变量名; 下面是一个定义结构体指针的实例: //结构体 struct stu{ char *name; //姓名 int num; //学号 int age; //年龄 char group; //所在小组 ...
  • C语言指针五——指针应用:链表

    千次阅读 2021-05-22 12:47:06
    C语言指针五——指针应用:链表——从代码猜测作者的意图毕竟是一件痛苦的事,这也是为什么许多人接手别人的项目宁愿从头做起也不愿意使用现有代码的原因。链表是一种重要的数据结构,它是许多其他数组结构的和算法...
  • 通常认为,C语言之所以强大,以及其自由性,很大部分体现在其灵活的指针运用上,甚至认为指针C语言的灵魂。这里说通常,是广义上的,因为随着编程语言的发展,指针也饱受争议,并不是所有人都承认指针的“强大”和...
  • C语言指针用星号和箭头表示有区别吗 * p ++和i→next表达意思一样吗?菜鸟一个,请各位多多 指点下!
  • C语言是跟内存打交道的语言,指针就是内存地址。指针无处不在,指针并不可怕,相反,等你学到一定程度后,会有一种,看见指针就会有亲切的感觉。指针是很好玩的东西。大多数人觉得指针难学,都是因为觉得它太抽象,...
  • C语言中的结构体指针赋值问题

    千次阅读 2022-03-10 21:51:08
    在对数组或者接收到的数据进行赋值时,往往因为结构体中含有指针而无法获取接收到的数据,那么如何才能获取结构体中的指针指向的内容呢?这就涉及到两个部分的内容。 1、通过memcpy()赋值或者对数据进行结构体的...
  • C语言-指针操作

    万次阅读 多人点赞 2016-11-30 23:29:16
    0.引入 在C语言中,
  • 如何在C语言中使用函数指针 函数指针的定义 int (*p)(int,int); int代表的是指针变量名,两个int代表,函数参数有两个,且都为int型,当然以上定义只为示例,需要根据不同的函数,指定不同的参数类型和参数个数。...
  • C语言箭头和点运算

    2020-09-18 20:22:30
    点运算是结构体变量访问其成员的操作符 箭头运算是结构体指针访问其指向的成员变量的操作符
  • 第三章 C语言指针

    2020-02-14 12:08:46
    一、指针数组和数组指针 1、字面意思理解指针数组和数组指针 指针数组的实质就是一个数组,这个数组中存储的内容全部是指针变量 数组指针的实质是一个指针,这个指针指向的是一个数组。 2、分析指针数组和数组指针...
  • 如果I是指针的话,就不能通过"."来调用,而只能使用"->"来调用。 在C语言中不存在对象的概念。 这种情况的出现是因为使用了结构,例如 struct CandyBar{ float weight; int calorie; }; 在程序中 CandyBar ...
  • 原标题:C语言指针最详尽的讲解 指针对于C来说太重要。然而,想要全面理解指针,除了要对C语言有熟练的掌握外,还要有计算机硬件以及操作系统等方方面面的基本知识。所以本文尽可能的通过一篇文章完全讲解指针。为...
  • 还没搞懂指针,不会吧! 不会吧!
  • C语言函数指针调用函数

    千次阅读 2015-07-01 21:26:18
    C语言可以定义指针变量指向函数,通过指针来调用函数。 使用: 1、定义函数指针变量: 函数返回值类型 (*指针变量名)(); 2、将已有函数入口赋值给函数指针变量:fnPt = avg; 3、使用指针变量调用函数:(*指针变量名)...
  • c语言箭头的用法

    万次阅读 多人点赞 2016-01-07 10:27:46
    运算符 -> 是指向结构体成员运算符,结合方向为自左向右。 举例说明如下: #include // 结构体的声明与定义 struct {  char name[10];  int age;  char sex; }person;... i = pers

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,136
精华内容 2,854
关键字:

c语言箭头指针的作用