相关疑难解决方法(0)

试图理解C中指针的行为,我对以下内容感到有点惊讶(下面的示例代码):

#include <stdio.h>

void add_one_v1(int *our_var_ptr)
{
    *our_var_ptr = *our_var_ptr +1;
}

void add_one_v2(int *our_var_ptr)
{
    *our_var_ptr++;
}

int main()
{
    int testvar;

    testvar = 63;
    add_one_v1(&(testvar));         /* Try first version of the function */
    printf("%d\n", testvar);        /* Prints out 64                     */
    printf("@ %p\n\n", &(testvar));

    testvar = 63;
    add_one_v2(&(testvar));         /* Try first version of the function */
    printf("%d\n", testvar);        /* Prints 63 ?                       */
    printf("@ %p\n", &(testvar));   /* Address remains identical         */
}

输出:

64
@ 0xbf84c6b0

63
@ 0xbf84c6b0 …

我正在尝试使用C指针文献.在其中一个插图中,我遇到了以下代码.

# include <stdio.h>

int main()
{
     static int a[]={0,1,2,3,4};
     static int *p[]={a, a+1, a+2, a+3, a+4};

     int **ptr;

     ptr =p;

     **ptr++;
     printf("%d %d %d\n", ptr-p, *ptr-a, **ptr);

     *++*ptr; 
     printf("%d %d %d\n", ptr-p, *ptr-a, **ptr);

     ++**ptr;
     printf("%d %d %d\n", ptr-p, *ptr-a, **ptr);

     return 0;
}

我收到输出为.

1 1 1
1 2 2
1 2 3

我在为这个输出辩护时遇到了问题.我在副本上制作了很多盒子,以便轻松掌握问题.我能够证明输出的合理性1 1 1,我的麻烦始于声明,*++*ptr.

因为,一元运算符从右到左执行.因此,*ptr将首先处理,然后ptr将增加值.在这个增量之后,我不确定会发生什么,书中说不知何故p也会增加指向此数组中的下一个元素.输出1 2 2只能通过增量来实现p.

我不确定这种问题是否恰好适合stackoverflow.
我尽我所能,浪费了至少10页,上面画着盒子.

任何澄清将不胜感激.

表达式1:*p++;where p是指向整数的指针.

p将首先递增,然后由于关联性(从右到左)获取它指向的值.这样对吗？

表达式2:a=*p++;where p是指向整数的指针.

首先取值,p然后分配给a第一个然后p由于后增量而增加.这样对吗？

这是pop()函数,我写的是弹出一个堆栈的元素.到目前为止,我已成功将元素推入堆栈并显示堆栈.所以,我想我的pop()功能在某处做错了.这是我的pop功能:

void pop(int newstack[], int *newtop, int bound )
{
    int item;
    if(*newtop<0)
        printf("\n CAUTION!!! UNDERFLOW");
    else
    {
        item=newstack[*newtop];
        *newtop--;
        printf("\n Element popped->%d",item);
    }
}

我没有机会,我也发布了这个show()功能:

void show_stack(int newstack[], int *top)
{
    int i;
    printf("\n");
    for(i=0;i<=*top;i++)
        printf("%d",newstack[i]);
}     

我猜show函数没有错误.

我正在学习c编程语言的基本知识。现在我对指针部分感到困惑。书中有原问题：

数组 a 有一些值，指针 p 现在位于 a[1]：

a[0]:10
a[1]:20  <---p
a[2]:30
a[3]:40
a[4]:50

问题清单：

1. *p执行后的值是* p++什么？
2. 的价值是* ++p什么？
3. 的价值是++ * p什么？

那么，*p++, * ++p,之间有什么区别++*p？

在我看来：

1. *p++意味着移动指针p指向下一个元素，所以第一个答案是 30。
2. 的差异*p++和*++p一样的差异i++和++i。所以第二个答案是 30。
3. *p表示指针p的值，所以++*p表示让p值增加1。所以第三个答案是21；

我对吗？

这可能是“ c++ 101”级别的问题，但有一些相关的痛苦，所以我会要求评论以保持自信。

我有一些遗留代码支持返回到c++11及之前的这一行：

iTmp = ~iTmp++;

在代码更改为c++17之前，此方法 100% 有效。更改为c++17后，它会计算出不同的值，但并非总是如此。这取决于该行在代码中的位置，是先执行 2 的补码还是先执行增量。

另外，如果您尝试强制使用括号，则会出现编译器错误：

iTmp = (~iTmp)++;

error C2105: '++' needs l-value

这对我来说很有意义，因为 2 的补码结果不是中间变量，因此 ++ 没有任何可操作的内容。

我的研究告诉我

1. 这是“执行顺序”失败。
2. 运算符优先级并不是这种情况下失败的主要原因。
3. 二进制补码不是就地操作，因此它不会更改 iTmp，而是返回一个值。
4. 遗留代码的工作靠运气 - 可能是由于编译器错误或错误总是强制执行运算符评估顺序。

我的评价正确吗？

对我来说，一个非常微妙的区别是前面的代码无效，但这一行可以：

if ( ++iTmp > 0)

我没想到升级到c++17会导致这个微妙的错误，但我不得不将代码更改为以下内容来解决问题：

iTmp = ~iTmp;
iTmp++;

有人可以解释为什么在输出中3 4 4打印而不是打印吗4 4 4？

#include <stdio.h>

int main(){

    int a[] ={0,1,2,3,4};
    int *p[] = {a,a+1,a+2,a+3,a+4};
    int **ptr= p; 

    ptr++;
    printf("%d %d %d\n",ptr-p,*ptr-a,**ptr);
    *ptr++;
    printf("%d %d %d\n",ptr-p,*ptr-a,**ptr);
    *++ptr;
    printf("%d %d %d\n",ptr-p,*ptr-a,**ptr);
    ++*ptr;
    printf("%d %d %d\n",ptr-p,*ptr-a,**ptr);

    return 0;
}

* p ++通常将1加到指针，然后再引用。但是printf只是在取消引用后才使用该值，而指针先增加后又取消引用。

#include<stdio.h>

int main()
{
    int a[] = { 10,20,30 };
    int *p = a;

    printf("%d\n", *p++);//this makes p point at 20 but prints 10
    printf("%d\n", *p);//prints 20
    printf("%d\n", a[0]);//prints 10

}

有人可以解释为什么会这样吗？

提前致谢

我正在学习指针基础知识.请查看我的示例代码并告诉我发生了什么.

void main()
{
     int i, *j;
     i = 2;
     j = i;
     printf("%d", j);
     printf("\n%d", j + 1);
     printf("\n%d", j + 2);
}

我的输出是

2 6 10

请解释一下..