プログラマ専用SNS ミクプラ

> ポインタというのはアドレスが入っているわけですよね？すると、②のtest先頭要素のアドレスがこの場合だと③のpxに入ってくるということでいいのでしょうか？

そうです。

> そして、*pxでtestのアドレスの中身を操作している。？その際、今回はポインタを使っているので、値はコピーではなくもとの値そのものを操作していることになりますよね？

pxには、呼び出し側のtestの先頭アドレスという値が入っています。
*pxとすれば、pxが指している領域の内容を取得できます。

なお、avg関数における

>    sum = sum + *(px+1);

は正しくありません。+1ではなく、+jでなければなりません。
あるいは、

    sum += px[j];

と書く方が簡潔かもしれません。
p をポインタ変数、n を整数とするとき、一般に
*(p+n) と p[n] は等価です。

くだんの結果によると、関連するアドレスとその中身は
下図のようになっています。

 アドレス       中身
           +------------+
0x0064FDF8 | 0x0064FDFC |
           |            |
           +------------+
0x0064FDFC | 0x0064FE00 |
           |            |
           +------------+
0x0064FE00 |         10 |
           |            |
           +------------+

>         printf("     *p = %d\n",*p);　　　　②　pにはiのアドレスが格納されていてそのアドレスの中にある値は10ということですよね？

そうです。

> 　　　　printf("**point = %d\n",**point);　③　pointのなかにはpのアドレスが格納され、さらにpの中にはiのアドレスがあるので、そ　
>         　　　　　　　　　　　　　　　　　　　　その中アドレスの中にある値は10ということですよね？

そうです。

>         printf(" *point = %p\n",*point);　　⑥　
>         printf("     &p = %p\n",&p);　　　　⑦　ここはp = &iをしていますが、この場合はp自身のアドレスを表しているのですよね？

p = &iは、していないです。
&pは、pのアドレスです。pointの値と同じです。

>         printf("  point = %p\n",point);　　⑧　　
>         printf(" &point = %p\n",&point);　　⑨ここも⑦と同じように、point自身のアドレスを表しているだけですよね？

そうです。

>       i = 10
>      *p = 10
> **point = 10
>      &i = 0064FE00
>       p = 0064FE00
>  *point = 0064FE00
>      &p = 0064FDFC
>   point = 0064FDFC
>  &point = 0064FDF8
> 
> ⑥・・・よく分からないです。
> pにはiのアロレスが格納され、*pの値は10になりますよね？すると、pointに格納されているのはpのアドレスで値は10になると思う
> のですが・・・。？？？？

「pointに入っているのはpのアドレス」までは、そのとおりです。
pのアドレスですから、0x0064FDFCです。
0x0064FDFC（pのアドレス）が指している先が、0x0064FE00（iのアドレス）です。
0x0064FE00（iのアドレス）が指している先が、10（iの値）です。

> ⑧・・・ここのよくわからないです。。

pointの値（0x0064FDFC）は、pのアドレスです。ここから、すぐ上の段落へと続いていきます。
つまり、
pointは&p（pのアドレス）に等しいです。
pは&i（iのアドレス）に等しいです。

#include <stdio.h>

int main(void) {

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

for(i = 0; i < sizeof a /sizeof a[0]; i++) {
	sum += *p++;
}

printf("%d",sum);

return 0;
}

> このコードってちゃんと合計でる？私のだと出ないのですが。

合計値が正しくないのは、最初にゼロで初期化していないためです。

> 又、for(i = 0; i < sizeof a /sizeof a[0]; i++)のところが

sizeof a は、配列a全体の大きさ（バイト数）を得ます。
sizeof a[0] は、配列aの先頭要素の大きさを得ます。
したがって、sizeof a /sizeof a[0] は、配列aの要素数を得ます。今回の例では、10です。
配列の要素数をコンピュータに数えさせる際の、定番のやり方です。

> あと、sum += *p++;ってのはsum = sum + *p;と同じことですよね？

同じではありません。
sum = sum + *p;
p++;
の２つの文と同じです。

こんな絵が参考になるでしょうか。

 a[0] a[1] a[2] a[3] a[4]  ...
+----+----+----+----+----+
|  1 |  2 |  3 |  4 |  5 | ...
+----+----+----+----+----+
  ↑
p = a; で、pはaの先頭要素を指す。

for文によるループに入る。

sumに、現在pが指している領域の内容（==1）を加える。
pを、1要素分だけ進める。
この2行が、「sum += *p++;」の意味。

 a[0] a[1] a[2] a[3] a[4]  ...
+----+----+----+----+----+
|  1 |  2 |  3 |  4 |  5 | ...
+----+----+----+----+----+
       ↑
pは、ここを指している。
終了条件を満たしていないので、ループの中の処理を続ける。

sumに、現在pが指している領域の内容（==2）を加える。
pを、1要素分だけ進める。

 a[0] a[1] a[2] a[3] a[4]  ...
+----+----+----+----+----+
|  1 |  2 |  3 |  4 |  5 | ...
+----+----+----+----+----+
            ↑
     pは、ここを指している。
終了条件を満たしていないので、ループの中の処理を続ける。

以下省略

#include <stdio.h>

int main(void) {
	char *p;
	char *str = "hello";
	
	for(p = str; *p !='\0'; p++) {
		putchar(*p);
	}
	return 0;
}

> forの中身なのですが、p++の所って*p++でもできますよね？テキストではp++ですけど。

*p++と書いても、プログラムの動作は全く同じです。
つまり、今回の場合、* を付けることは無意味です。

【解説】
*p++ を実行する、ということは、次の２つの文を実行することと等価です。
*p;
p++;

ここで、
*p;
という文は、p が指している領域の内容を取得するだけで、他の変数に代入するなどの
処理を行なっていません。
例えば、int 型の変数 a に任意の値が入っているとして、
a;
という文に実質的な意味がないことはおわかりかもしれません。それと全く同じです。

> ②は・・・・。分からないです。

②の場合は、char型へのポインタの配列を定義しようとしています。
配列の要素数は、１です。

なお、配列の初期化を行なう際は、要素を { と } で囲む必要があります。
char *str[/url] = { "hello" };
のようにしてください。

char[color=#FF0000>*[/color] char4[2][3] = {{"eee", "fff", "ggg"}, {"hhh", "iii", "jjj"}};

char str4[2][4] = {{'e', 'e', 'e', '\0'}, {'f', 'f', 'f', 'f'}};

ポインタ変数と配列は別物ですので別々にして理解を深めた方が良いでしょう。

char* a = "abc";

これを図にしてみると
char* 型変数である a がメモリの p番地 に生成されたとすると
      +----------------------------+
p番地 | "abc"を指すアドレス(n番地) |
      +----------------------------+

そして n番地は以下の様になっています。

        +----------+
n番地   | 'a'      |
        +----------+
n+1番地 | 'b'      |
        +----------+
n+2番地 | 'c'      |
        +----------+
n+3番地 | '\0'     |
        +----------+


これを単に配列にしているだけですので、

char* b[3] = {"abc", "de", "f"};

char* 型配列変数である b がメモリの p番地 に生成されたとすると

        +-----------------------------+
p番地   | "abc"を指すアドレス(n1番地) |
        +-----------------------------+
p+1番地 | "de"を指すアドレス(n2番地)  |
        +-----------------------------+
p+2番地 | "f"を指すアドレス(n3番地)   |
        +-----------------------------+

         +----------+            +----------+            +----------+
n1番地   | 'a'      |   n2番地   | 'd'      |   n3番地   | 'f'      |
         +----------+            +----------+            +----------+
n1+1番地 | 'b'      |   n2+1番地 | 'e'      |   n3+1番地 | '\0'     |
         +----------+            +----------+            +----------+
n1+2番地 | 'c'      |   n2+2番地 | '\0'     |
         +----------+            +----------+
n1+3番地 | '\0'     |
         +----------+


単純にこれだけの事です。

#include <stdio.h>
#include <string.h>

int main(void) {
	char str1[/url] = "abcdefg";
	char str2[80], *p1, *p2;

	p1 = str1 + strlen(str1)-1;
	p2 = str2;

	while(p1 >= str1){
		*p2++ = *p1--;
		*p2 ='\0';
	}
	printf("%s,%s",str1,str2);
	return 0;
}

> p1 = str1 + strlen(str1)-1;
> p2 = str2;
> この二つはそれぞれアドレスを入れてるのですよね？配列の宣言がしてありますから。

p1は、str1の先頭のアドレスから、str1の文字数分だけ進み、1つ戻っています。
str1の文字数は7ですので、結局、p1は、str1の先頭から6文字分進んでいます。
つまり、p1は、str1の最後の文字'g'を指しています。
一方、p2は、str2の先頭を指しています。

> whileからが分からないです。

7文字だと説明が少し長くなりますので、str1[/url]に"abc"が入っていることにして説明します。

【whileの前の準備段階】
p1は、上で書いたとおり、str1の最後の文字'c'を指している。
p2は、str2の先頭文字を指している。この時点では、内容は不定（str2を初期化していないため）。

【whileの中身】
p1は'c'を指しているので、str1（つまり、先頭文字'a'のアドレス）以上の値を持つ。
ループを継続する条件を満たしているので、ループの中に入る。

p2が指している場所（str2の先頭、0文字目と呼ぶことにする）に、
p1が指している場所の内容'c'を代入する。
代入後、p2のアドレスを1つ進めて、p1のアドレスを1つ戻す。
さらに、そのときp2が指している場所に、文字列終端用の'\0'を代入する。
この時点で、p2はstr2の1文字目（'\0'）を指し、p1は'b'を指している。
まだ、ループの継続条件を満たしている。

p2の1文字目に、p1が指している'b'を代入する。
代入後、p2のアドレスを1つ進めて、p1のアドレスを1つ戻す。
さらに、そのときp2が指している場所に、文字列終端用の'\0'を代入する。
この時点で、p2はstr2の2文字目（'\0'）を指し、p1は'a'を指している。
まだ、ループの継続条件を満たしている。

p2の2文字目に、p1が指している'a'を代入する。
代入後、p2のアドレスを1つ進めて、p1のアドレスを1つ戻す。
さらに、そのときp2が指している場所に、文字列終端用の'\0'を代入する。
この時点で、p2はstr2の3文字目（'\0'）を指し、p1は'a'の直前（内容は不定）を指している。
ここで、ループの継続条件を満たさなくなる。

【whileを抜けた後】
str1は"abc"の先頭文字'a'を指しているので、書式文字列"%s"を使うと、"abc"と出力する。
一方、while文によるループの中でp2が指している場所に文字を代入しているということは、
準備段階においてp2をstr2の先頭文字のアドレスで初期化していたことが効いてきて、
結局のところstr2の要素の中に文字を代入したことになる。書式文字列"%s"を使うと、"cba"と出力する。

【結論】
str2には、str1の文字順を逆転させた内容が入る。

図を描くと、こんな感じです。

【準備段階】

     +------+------+------+------+
str1 | 'a'  | 'b'  | 'c'  | '\0' |
     +------+------+------+------+
                      ↑
            p1は、ここを指している

     +------+------+------+------+
str2 | 不定 | 不定 | 不定 | 不定 | ......
     +------+------+------+------+
        ↑
p2は、ここを指している


【ループ（１回目終了時）】

     +------+------+------+------+
str1 | 'a'  | 'b'  | 'c'  | '\0' |
     +------+------+------+------+
               ↑
     p1は、ここを指している

     +------+------+------+------+
str2 | 'c'  | '\0' | 不定 | 不定 | ......
     +------+------+------+------+
               ↑
     p2は、ここを指している


【ループ（２回目終了時）】

     +------+------+------+------+
str1 | 'a'  | 'b'  | 'c'  | '\0' |
     +------+------+------+------+
        ↑
p1は、ここを指している

     +------+------+------+------+
str2 | 'c'  | 'b'  | '\0' | 不定 | ......
     +------+------+------+------+
                      ↑
            p2は、ここを指している


【ループ（３回目終了時）】

     +------+------+------+------+
str1 | 'a'  | 'b'  | 'c'  | '\0' |
     +------+------+------+------+
 ↑
p1は、ここを指している（内容は不定）

     +------+------+------+------+
str2 | 'c'  | 'b'  | 'a'  | '\0' | ......
     +------+------+------+------+
                             ↑
                   p2は、ここを指している

この時点でループの継続条件を満たさなくなる。
"abc"と"cba"を出力する。

int main(void) {
	char *p;
	p = "aa bb cc";
	printf(p);
	return 0;
}

> この場合のgets(str)のstrというのは文字列のポインタとなるのですよね？

そうです。
ところで、ループの継続条件である

>        }while(strcmp(p,str));

について説明していただけますか？