小甲鱼 S1E21：指针作业部分学习总结

     首先第一件事，大家一定要先去鱼C花费10鱼币解锁小甲鱼的练习并加以思考，里面的内容非常精彩，本人的总结只是冰山一角和粗糙的个人理解！

       关于指针，首先应该想清楚通常程序猿口中的“指针”，指的是什么东西。其实就是地址，或者说内存的地址。

       首先我们应该想清楚一件事，指针变量只能存放地址吗？答案是肯定的。大家切记，指针变量只能存放地址。要确保这个规则已经熟稔于心！

接下来给大家两个辨析：

请问 int * a, b, c; 定义了多少个指针变量？

请问 int *(a, b, c); 定义了多少个指针变量？"

       关于第一个定义，很明显第一个逗号前面的是定义了一个指针变量，而后面的b,c则是整型变量。第二个定义应该是一个语法错误，想定义三个指针变量可以用int *a,*b,*c的方式，而非这种声明指针变量再加一个括号的形式。

       下面是一个概念：不能简单地通过检查内存中的一个值来判断它的类型。其实它还可以被解释为机器指令！内存中存放的值不是 0 就是 1，如何解释，主要看定义。如果你看不到定义（你在逆向破解一个程序），那么为了判断值的类型，你必须观察程序中这个值的使用方式（如果使用整型算术指令，这个值就被解释为整数；如果使用浮点型指令，它就是浮点数）。

      另外，关于取地址运算符（&）。取址操作符（&）的作用对象应该是一个左值，而常数是右值。

      关于这个问题大家可以参考一下小甲鱼的这篇文章【新提醒】什么是 lvalue，什么是 rvalue？,《带你学C带你飞》【第一季】,C\C++交流,鱼C论坛 - Powered by Discuz! (fishc.com.cn)       对左值和右值有一个更加清晰的认知，而不是简单的字面上的在赋值号左侧就叫左值，反之是右值。左值右值的定义或者说概念不是这样的。我们可以简单理解为左值是可以识别或者定位存储位置的标识符。

       我们继续看下一个问题：

#include <stdio.h>

int main()
{
        int a, b;

        b = 110;
        a = &b;

        printf("%d\n", *a);

        return 0;
}

        这段代码是否可以运行呢？

       答案是否定的。sizeof(int) == sizeof(*int) 说明存放指针变量和存放整型变量所需的存储空间是一样的。但这并不说明他们就可以互相取代。我们在vc6.0中运行一下看看！8J

!I~uA
编译器m`c4L!Wu_VJ^kUnF8q{?ofA9d6(8J!I~uA
m`c4L!Wu_VJ^kUnF8q{?o

       编译器也告诉我们，无法将指针类型转换为整形。

      我们接着看：

#include <stdio.h>

int main()
{
        int *a;

        printf("%p\n", a);

        return 0;
}

       在代码中我们没有对指针变量进行初始化处理，这是一种很危险的行为。没有进行初始化，意味着我们的指针会没有目标的乱指，即产生一系列的随机值。并且在VC6.0中编译器对此就进行了报错。

        即未初始化使用的局部变量 'a' 。

       我们在回顾一个简单的问题，你觉得将取址运算符（&）作用于一个常数，然后试图打印该常数在内存中的地址，这样做可取吗？我看看一段简单的代码：

include <stdio.h>

int main()
{
        printf("%p\n", &110);

        return 0;
}

w想必

       这个问题想必是不可以的。前面提到取地址操作符（&）的作用对象应该是一个左值，而110很明显是一个常量。至于结果我想不必再看了。这个问题如果还不清楚的话，立即推今晚复习到两点！

我们再看一段代码，简单计算一下它的结果应该是多少：

#include <stdio.h>

int main()
{
        int a = 110;
        int *b = &a;

        *b = *b - 10;

        printf("a = %d\n", a);

        return 0;
}

       当我们将a的地址存进指针变量b后，对指针变量b进行操作即可影响a的值。我们可以粗略的认为*b就是常量a，但是这两者却还有细微的差别！

       鱼说：“指针变量 b 既是左值，也是右值。看 *b = *b - 10; 这个语句，赋值号右边，*b 间接访问变量 a 的值，因为用的是它的值，所以是右值；赋值号左边，*b 用于定位变量 a 的存储位置，然后将右边表达式的值存放进去，所以此时为左值。”>

 下面我们看几个动手的题

1.

        我们看到代码里给出了中间变量t，所以我们猜测应该是利用中间变量t和指针变量进行数值的交换。

#include <stdio.h>

int main(void)
{
        int a, b, c, t;
        int *pa, *pb, *pc;
        
        printf("请输入三个数：");
        scanf("%d%d%d", &a, &b, &c);
        
        pa = &a;
        pb = &b;
        pc = &c;
        
        if (a > b)
        {
                t = *pa;
                *pa = *pb;
                *pb = t;
        }
        
        if (a > c)
        {
                t = *pa;
                *pa = *pc;
                *pc = t;
        }
        
        if (b > c)
        {
                t = *pb;
                *pb = *pc;
                *pc = t;
        }
        
        printf("%d <= %d <= %d\n", *pa, *pb, *pc);
        printf("%d <= %d <= %d\n", a, b, c);
        
        return 0;
}

2. 验证尼科彻斯定理：任何一个大于 2 的整数的立方都可以表示成一串连续奇数的和，这些奇数一定是要连续的（比如 3^3 == 7 + 9 + 11）。

#include <stdio.h>

int main()
{
        int i, j, n, cubed, sum = 0;

        printf("请输入一个整数：");
        scanf("%d", &n);

        cubed = n * n * n;//很明显cubed是三次幂

        for (i = 1; i < cubed; i += 2)
        {
                for (j = i; j < cubed; j += 2)
                {
                        sum += j;
                        if (sum == cubed)
                        {
                                if (j - i > 4)
                                {
                                        printf("%d = %d + %d ... + %d\n", cubed, i, i+2, j);
                                }
                                else
                                {
                                        printf("%d = %d + %d + %d\n", cubed, i, i+2, i+4);
                                }
                                goto FINDIT;
                        }

                        if (sum > cubed)
                        {
                                sum = 0;
                                break;
                        }
                }
        }

FINDIT:

        return 0;
}

程序分析：

       程序中我们要实现的三个奇数通过i和j或者i来刻画。联想二维数组的刻画，我们选择使用for的双重循环。

       并且根据该定理，必有三个连续奇数和使之成立，故只要满足条件，则必是三个连续奇数。所以这利用里层循环寻找合适的第一个奇数i的值，层层循环逼近i的值，当满足cubed==sum时，就找到了合适的值。在判断这里i与j差了多少即可得出结果。这是我认为这段代码的思想。(学的时间不长，所以无法用专业的语言解释，献丑了）

       在程序进入循环时，我们通过单步调试观察变量值的变化：

       此时，i和j都是1。我们往下单步走：j的值依次为1 3 5 7 9 ，且当j为9时，sum的值来到了25，在进行1次循环，j的值来到了11，此时sum的值来到了36，按照代码设置的判断条件，此时sum清零，并退出第二层循环。如图所示：

 

 

      这时i的值来到了3，j的值为11。

        我们重复操作，当我们发现cubed的值等于27时，此时i的值为7，j为11，如图所示。

       并且11-7（j-i） 的值为4，根据if判断，则此时三个奇数为7 9 11。

3. 改进上一题的代码，用户输入一个表示范围的最大值 count，程序将测试 3 ~ count 所有的整数是否都符合尼科彻斯定理。

#include <stdio.h>
#include <stdbool.h>

int main()
{
        int i, j, n, count, cubed, sum = 0;
        bool result = true; // 用于存放验证结果
        char answer;

        printf("请输入一个整数：");
        scanf("%d", &count);

        int array[count][4];
        // 变长数组无法再定义是初始化，只能手动了...
        for (n = 3; n <= count; n++)
        {
               // 初始化第一列，因为后边用于验证 
               array[n][0] = 0; 
        }

        for (n = 3; n <= count; n++)
        {
                cubed = n * n * n;
                for (i = 1; i < cubed; i += 2)
                {
                        for (j = i; j < cubed; j += 2)
                        {
                                sum += j;
                                if (sum == cubed)
                                {
                                        array[n][0] = cubed;
                                        array[n][1] = i;
                                        array[n][2] = i + 2;
                                        array[n][3] = j;
                                        
                                        goto FINDIT;
                                }

                                if (sum > cubed)
                                {
                                        sum = 0;
                                        break;
                                }
                        }
                }

        FINDIT:
                sum = 0;
        }

        // 检查
        for (n = 3; n <= count; n++)
        {
                if (array[n][0] == 0)
                {
                        result = false;
                        break;
                }
        }
        
        if (result)
        {
                printf("经验证，3 ~ %d 之间所有的整数均符合尼科彻斯定理！\n\n", count);
                printf("是否打印所有式子(y/n)：");
                getchar();
                scanf("%c", &answer);
        }
        else
        {
                printf("验证失败：整数 %d 无法找到对应的连续奇数！\n");
        }

        if (answer == 'y')
        {
                // 打印
                for (n = 3; n <= count; n++)
                {
                        if (array[n][3] - array[n][1] > 4)
                        {
                                printf("%d^3 == %d == %d + %d +... + %d\n", n, array[n][0], array[n][1], array[n][2], array[n][3]);
                        }
                        else
                        {
                                printf("%d^3 == %d == %d + %d + %d\n", n, array[n][0], array[n][1], array[n][2], array[n][3]);
                        }
                }
        }

        return 0;
}

       该段代码使用二维数组存放运行的结果，并且结果通过布尔型变量判断是否成立，增加了判断是否打印的功能，在完善程序方面值得我们思考！由于本例与上题思想一致，这里不过多赘述。