Lbu0h9

ポインタの裏話
岡﨑 直観
okazaki at ecei.tohoku.ac.jp
http://www.chokkan.org/
@chokkanorg
ポインタの裏話
プログラミング演習A 1

このような説明を
覚えていますか?
知らなくても全く問題ありません
ポインタの裏話 プログラミング演習A 2

int x = 0;
&xは変数xの「アドレス」
「番地」「住所」を返す
0
変数x
&x
メモリ空間,
記憶空間
変数xのアド
レス(住所)
ポインタの裏話 プログラミング演習A 3

____
/ \ 何言ってたんだこいつ?
/ ⌒ ⌒ \ 番地 アドレス ぬるぽ
/ (●) (●) \ \ /
| ､“ ﾞ)(__人__)" ) __________
\ ｡` ⌒ﾟ:j´ ,/ jﾞ~~| | | |
__/ \ |__| | | |
| | / , \n|| | | |
| | / / r. ( こ) | | |
| | | ⌒ ーnnn |\ (⊆ｿ .|_|____________|
¯ \__､("二)¯¯¯¯¯l二二l二二 _|_|__|_
ポインタの裏話 プログラミング演習A 4

ポインタの裏話 プログラミング演習A 5

int x = 0;
int *p = &x;
*p = 1;
変数xの値が1になるのは分かる
ポインタの裏話 プログラミング演習A 6

.|
.|
∩___∩ |
| ノ\ ,_ ヽ .|
/ ●゛ ● | .J
| ∪ ( _●_) ミ
彡､ |∪| |
/ ∩ノ ⊃ ヽ
( \ / _ノ | |
\ " / | |
\ /¯¯¯ /
¯¯¯¯
何故こんな
回りくどい
ことを?
ポインタの必然性が感じられない
ポインタの裏話 プログラミング演習A 7

ポインタの裏話 プログラミング演習A 8

計算機のメモリの
仕組みを知らない
. .: : : : : : : : :: :::: :: :: : :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
. . : : : :: : : :: : ::: :: : :::: :: ::: ::: ::::::::::::::::::::::::::::::::::::::
. . .... ..: : :: :: ::: :::::: :::::::::::: : :::::::::::::::::::::::::::::::::::::::::::::
Λ_Λ . . . .: : : ::: : :: ::::::::: :::::::::::::::::::::::::::::
/:彡ミ゛ヽ;)ー､ . . .: : : :::::: :::::::::::::::::::::::::::::::::
/ :::/:: ヽ、ヽ、 ::i . .:: :.: ::: . :::::::::::::::::::::::::::::::::::::::
/ :::/;;: ヽ ヽ ::l . :. :. .:: : :: :: :::::::: : ::::::::::::::::::
¯¯¯(_,ノ ¯¯¯ヽ､_ノ¯¯¯¯
ポインタの裏話 プログラミング演習A 9

ポインタの必要性が
分からない
¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯｣
―――――――――――――‐┬┘
|
____.____ | .__ いらないポインタを
| | | | |\_\ 窓から
| | ∧_∧ | | | |.◎.| 投げ捨てろ
| |( ´∀`)つ ミ | | |.: |
| |/ ⊃ ﾉ | | .\|.≡.|
¯¯¯¯'¯¯¯¯ | ¯
ポインタの裏話 プログラミング演習A 10

今回はポインタに関する
知識を⼿加減せずに
すべて説明する
ポインタの裏話 プログラミング演習A 11

変数があれば⼗分じゃね?
ポインタの裏話 プログラミング演習A 12

その答えは
「機械語」と
C⾔語の「⽴ち位置」
ポインタの裏話 プログラミング演習A 13

CPU
ポインタの裏話 プログラミング演習A 14

⼈間の読むものではありません
ポインタの裏話 プログラミング演習A 15

#include
#include
int main(int argc, char *argv[])
{
int x = atoi(argv[1]);
printf("x = %d, &x = %08X¥n", x, &x);
return 0;
}
機械語への翻訳例
(コンパイル結果)
cc
gcc
※Visual C++ 2010を⽤い
Intel x86系CPUの機械語に変換
※主要コード部のみ表⽰
55 8b ec 51 8b 45 0c 8b 48 04 51 ff 15 a4 20 39
00 83 c4 04 89 45 fc 8d 55 fc 52 8b 45 fc 50 68
18 30 39 00 ff 15 9c 20 39 00 83 c4 0c 33 c0 8b
e5 5d c3
ポインタの裏話 プログラミング演習A 16

機械語のプログラムは16進数の羅列
CPUのレジスタは⼀時変数のようなもの
ポインタの裏話 プログラミング演習A 17

機
械
語
int main(int argc, char *argv[])
{
55 push ebp
8B EC mov ebp,esp
51 push ecx
int x = atoi(argv[1]);
8B 45 0C mov eax,dword ptr [ebp+0Ch]
8B 48 04 mov ecx,dword ptr [eax+4]
51 push ecx
FF 15 A4 20 2F 01 call dword ptr ds:[012F20A4h]
83 C4 04 add esp,4
89 45 FC mov dword ptr [ebp-4],eax
printf("x = %d, &x = %08X¥n", x, &x);
8D 55 FC lea edx,[ebp-4]
52 push edx
8B 45 FC mov eax,dword ptr [ebp-4]
50 push eax
68 18 30 2F 01 push 12F3018h
FF 15 9C 20 2F 01 call dword ptr ds:[012F209Ch]
83 C4 0C add esp,0Ch
return 0;
33 C0 xor eax,eax
}
8B E5 mov esp,ebp
5D pop ebp
C3 ret
C⾔語のコンパイル結果
強引に解釈すると
ebp-4が変数xへ
のポインタです
ポインタの裏話 プログラミング演習A 18
ア
セ
ン
ブ
リ
⾔
語

ポインタの裏話 プログラミング演習A 19

ポインタの裏話 プログラミング演習A 20

実⾏時間が速い
計算機の能⼒を最⼤限に引き出せる
ポインタの裏話 プログラミング演習A 21

ポインタを隠蔽しきれず
ちょっと中途半端
ポインタの裏話 プログラミング演習A 22

ポインタの裏話 プログラミング演習A 23

* + 巛 ヽ
〒 ! + 。 + 。
* 。
+ 。 | |
* + / / イヤッッホォォォオオォオウ!
∧_∧ / /
(´∀` / / + 。 + 。 * 。
,- f
/ ｭﾍ | * + 。 + 。 +
〈_} ) |
/ ! + 。 + + *
./ ,ﾍ |
ｶﾞﾀﾝ ||| j / | | |||
――――――――――――
ポインタの裏話 プログラミング演習A 24

── =≡∧_∧ =!!
── =≡(,, ・∀・) ≡ ｶﾞｯ ∧_∧
─ =≡○_ ⊂)_=_ \ 从/-=≡ r( .)
── =≡ > __ ノ ))< > -= 〉# つ
─ =≡ ( / ≡ /VV\-=≡⊂ ､ ﾉ
── .=≡( ノ =≡ -= し'
¯¯¯¯¯¯¯¯¯|
|
|
| ~~~~~~~~~~~~~~
| ポ イ ン タ 海 溝
ポインタの裏話 プログラミング演習A 25

||¯¯¯¯¯¯¯¯¯¯||
|| 基礎こそ ∧_∧ いいですね。
|| 重要! \ (ﾟДﾟ,,)
||________⊂⊂ |
∧ ∧ ∧ ∧ ∧ ∧ |¯¯¯¯|
( ∧ ∧ ( ∧ ∧ ( ∧ ∧ | |
~(_( ∧ ∧ __( ∧ ∧__( ∧ ∧¯¯¯
~(_( ∧ ∧_( ∧ ∧_( ∧ ∧ は~い、先生。
~(_( ,,)~(_( ,,)~(_( ,,)
~(___ﾉ ~(___ﾉ ~(___ﾉ
ポインタの裏話 プログラミング演習A 26

ポインタの裏話 プログラミング演習A 27

メモリ(主記憶)の構造
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00000000 7F 45 4C 46 01 02 01 06 01 00 00 00 00 00 00 00
0x00000010 00 02 00 12 00 00 00 01 00 01 08 90 00 00 00 34
0x00000020 00 00 1A A4 00 00 01 00 1A 34 00 20 00 05 00 28
0x00000030 00 1A 00 19 00 00 00 06 00 00 00 34 00 01 00 34
0x00000040 00 00 00 00 00 00 00 A0 00 00 00 A0 00 00 00 05
0x00000050 00 00 00 00 00 00 00 03 00 00 00 D4 00 01 00 D4
0x00000060 00 00 00 00 00 00 00 11 00 00 00 11 00 00 00 04
0x00000070 00 00 00 00 00 00 00 01 00 00 00 00 00 01 00 00
…
…
…
0xFFFFFFF0
ポインタの裏話 プログラミング演習A 28

主記憶の記憶状態の表現
0111111101000101010011000100011000000001000000100000……
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00000000 7F 45 4C 46 01 02 01 06 01 00 00 00 00 00 00 00
0x00000010 00 02 00 12 00 00 00 01 00 01 08 90 00 00 00 34
0x00000020 00 00 1A A4 00 00 01 00 1A 34 00 20 00 05 00 28
0x00000030 00 1A 00 19 00 00 00 06 00 00 00 34 00 01 00 34
0x00000040 00 00 00 00 00 00 00 A0 00 00 00 A0 00 00 00 05
…
0xFFFFFFF0
• 8ビット(=1バイト)をまとめて⼀つの升で表現
• ひとつの升は(0x00〜0xFF; 0〜255)の値を記憶できる
• 計算機が持っている升の数: 主記憶の量(バイト)
• この場合,0x100000000バイト = 4294967296バイト ≒ 4GB
• 16個の升をまとめて1⾏で⽰すのが慣例(← いろいろ便利なので)
• このため,番地(アドレス)を表現するときに16進数を使う
• ⾏と列を結合したものが番地(アドレス): 例えば0x00000028番地の値は0x1A
ポインタの裏話 プログラミング演習A 29

記憶内容の読み出し/書き込み
• 番地(位置)と型(⼤きさ)を指定する
• 00010100番地に対して…
• char (1バイト): 0x41
• short (2バイト): 0x4142
• int (4バイト): 0x41424344
• double (8バイト): 2393736.0
• char[3] (3バイト): {0x41, 0x42, 0x43}
• char*: “ABCD”
※演習室の計算機のCPUは
ビッグエンディアン
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
…
0x00010100 41 42 43 44 00 00 00 00 00 00 00 00 00 00 00 00
…
ポインタの裏話 プログラミング演習A 30

C⾔語の変数の
裏で番地と型が
管理されている
主記憶の仕組みを知らなくても
変数や配列が使えている
ポインタの裏話 プログラミング演習A 31

ポインタの裏話 プログラミング演習A 32

ポインタの裏話 プログラミング演習A 33
:

0x00000028
ポインタの裏話 プログラミング演習A 34

char(1バイト)として読む
// p: 0x00000028番地からchar(1バイト)にアクセスする手段
char *p = (char *)0x00000028;
// pが指している番地(0x00000028)の値を読み込む
v = *p;
vに0x1A (= 26) が代入される
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00000000 7F 45 4C 46 01 02 01 06 01 00 00 00 00 00 00 00
0x00000010 00 02 00 12 00 00 00 01 00 01 08 90 00 00 00 34
0x00000020 00 00 1A A4 00 00 01 00 1A 34 00 20 00 05 00 28
0x00000030 00 1A 00 19 00 00 00 06 00 00 00 34 00 01 00 34
0x00000040 00 00 00 00 00 00 00 A0 00 00 00 A0 00 00 00 05
0x00000050 00 00 00 00 00 00 00 03 00 00 00 D4 00 01 00 D4
0x00000060 00 00 00 00 00 00 00 11 00 00 00 11 00 00 00 04
0x00000070 00 00 00 00 00 00 00 01 00 00 00 00 00 01 00 00
…
…
…
0xFFFFFFF0
ポインタの裏話 プログラミング演習A 35

short(2バイト)として読む
// p: 0x00000028番地からshort(2バイト)にアクセスする手段
short *p = (short *)0x00000028;
// pが指している番地(0x00000028)の値を読み込む
v = *p;
vに0x1A34 (= 6708) が代入される
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00000000 7F 45 4C 46 01 02 01 06 01 00 00 00 00 00 00 00
0x00000010 00 02 00 12 00 00 00 01 00 01 08 90 00 00 00 34
0x00000020 00 00 1A A4 00 00 01 00 1A 34 00 20 00 05 00 28
0x00000030 00 1A 00 19 00 00 00 06 00 00 00 34 00 01 00 34
0x00000040 00 00 00 00 00 00 00 A0 00 00 00 A0 00 00 00 05
0x00000050 00 00 00 00 00 00 00 03 00 00 00 D4 00 01 00 D4
0x00000060 00 00 00 00 00 00 00 11 00 00 00 11 00 00 00 04
0x00000070 00 00 00 00 00 00 00 01 00 00 00 00 00 01 00 00
…
…
…
0xFFFFFFF0
※ビックエンディアンを仮定
ポインタの裏話 プログラミング演習A 36

int(4バイト)として読む
// p: 0x00000028番地からint(4バイト)にアクセスする手段
int *p = (int *)0x00000028;
// pが指している番地(0x00000028)の値を読み込む
v = *p;
vに0x1A340020 (= 439615520) が代入される
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00000000 7F 45 4C 46 01 02 01 06 01 00 00 00 00 00 00 00
0x00000010 00 02 00 12 00 00 00 01 00 01 08 90 00 00 00 34
0x00000020 00 00 1A A4 00 00 01 00 1A 34 00 20 00 05 00 28
0x00000030 00 1A 00 19 00 00 00 06 00 00 00 34 00 01 00 34
0x00000040 00 00 00 00 00 00 00 A0 00 00 00 A0 00 00 00 05
0x00000050 00 00 00 00 00 00 00 03 00 00 00 D4 00 01 00 D4
0x00000060 00 00 00 00 00 00 00 11 00 00 00 11 00 00 00 04
0x00000070 00 00 00 00 00 00 00 01 00 00 00 00 00 01 00 00
…
…
…
0xFFFFFFF0
※ビックエンディアンを仮定
ポインタの裏話 プログラミング演習A 37

double(8バイト)として読む
// p: 0x00000028番地からdouble(8バイト)にアクセスする手段
double *p = (double *)0x00000028;
// pが指している番地(0x00000028)の値を読み込む
v = *p;
vに0x1A34002000050028を浮動小数点で解釈したもの(1.882796×10 -182 )を代入
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00000000 7F 45 4C 46 01 02 01 06 01 00 00 00 00 00 00 00
0x00000010 00 02 00 12 00 00 00 01 00 01 08 90 00 00 00 34
0x00000020 00 00 1A A4 00 00 01 00 1A 34 00 20 00 05 00 28
0x00000030 00 1A 00 19 00 00 00 06 00 00 00 34 00 01 00 34
0x00000040 00 00 00 00 00 00 00 A0 00 00 00 A0 00 00 00 05
0x00000050 00 00 00 00 00 00 00 03 00 00 00 D4 00 01 00 D4
0x00000060 00 00 00 00 00 00 00 11 00 00 00 11 00 00 00 04
0x00000070 00 00 00 00 00 00 00 01 00 00 00 00 00 01 00 00
…
…
…
0xFFFFFFF0
※ビックエンディアンを仮定
ポインタの裏話 プログラミング演習A 38

こんなことも出来ます(voidポインタ)
// p: 0x00000028番地を指す手段(アクセス方法は指定しない)
void *p = (void *)0x00000028;
// 読み込み方法が指定されていないので,下のコードはコンパイルできない
v = *p;
// アクセス方法を一時的にintに指定(キャスト)してアクセス
v = *(int *)p;
vに0x1A340020 (= 439615520) が代入される
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00000000 7F 45 4C 46 01 02 01 06 01 00 00 00 00 00 00 00
0x00000010 00 02 00 12 00 00 00 01 00 01 08 90 00 00 00 34
0x00000020 00 00 1A A4 00 00 01 00 1A 34 00 20 00 05 00 28
0x00000030 00 1A 00 19 00 00 00 06 00 00 00 34 00 01 00 34
0x00000040 00 00 00 00 00 00 00 A0 00 00 00 A0 00 00 00 05
0x00000050 00 00 00 00 00 00 00 03 00 00 00 D4 00 01 00 D4
0x00000060 00 00 00 00 00 00 00 11 00 00 00 11 00 00 00 04
0x00000070 00 00 00 00 00 00 00 01 00 00 00 00 00 01 00 00
…
…
…
0xFFFFFFF0
ポインタの裏話 プログラミング演習A 39

ポインタ: 番地+アクセス⽅法の組
char *p = (char *)0x00000028;
番地: *pでアクセスしたい番地
pの値 → 0x00000028
アクセス方法: *pとしたときの型
*pの値 → 0x1A (char型)
ポインタの裏話 プログラミング演習A 40

つまり,ポインタ変数(例えばp)とは
• 基本的には番地を記憶する変数
char *p = (char *)0x00000028;
• このときpの値は0x00000028
• つまりint型の普通の変数と同じと思えばよい
• ただし,以下の特殊機能が⽤意されている
• *p: pの番地の値にアクセス
• p[i]: pからiだけ離れた番地の値にアクセス
• p+i: pからiだけ離れた番地を計算する
配列の正体
ポインタの裏話 プログラミング演習A 41

p[i] p+i
ポインタの裏話 プログラミング演習A 42

char*に対する操作
char *p = (char *)0x00000028;
v = *p; ++p;
v = *p;
v → 0x1A
v = p[1];
v = *(p+2);
p→0x00000029
v → 0x34 v → 0x34 v → 0x00
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00000000 7F 45 4C 46 01 02 01 06 01 00 00 00 00 00 00 00
0x00000010 00 02 00 12 00 00 00 01 00 01 08 90 00 00 00 34
0x00000020 00 00 1A A4 00 00 01 00 1A 34 00 20 00 05 00 28
0x00000030 00 1A 00 19 00 00 00 06 00 00 00 34 00 01 00 34
0x00000040 00 00 00 00 00 00 00 A0 00 00 00 A0 00 00 00 05
0x00000050 00 00 00 00 00 00 00 03 00 00 00 D4 00 01 00 D4
0x00000060 00 00 00 00 00 00 00 11 00 00 00 11 00 00 00 04
0x00000070 00 00 00 00 00 00 00 01 00 00 00 00 00 01 00 00
…
…
…
0xFFFFFFF0
ポインタの裏話 プログラミング演習A 43

short*に対する操作
short *p = (short *)0x00000028;
v = *p; ++p;
v = *p;
v → 0x1A34
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00000000 7F 45 4C 46 01 02 01 06 01 00 00 00 00 00 00 00
0x00000010 00 02 00 12 00 00 00 01 00 01 08 90 00 00 00 34
0x00000020 00 00 1A A4 00 00 01 00 1A 34 00 20 00 05 00 28
0x00000030 00 1A 00 19 00 00 00 06 00 00 00 34 00 01 00 34
0x00000040 00 00 00 00 00 00 00 A0 00 00 00 A0 00 00 00 05
0x00000050 00 00 00 00 00 00 00 03 00 00 00 D4 00 01 00 D4
0x00000060 00 00 00 00 00 00 00 11 00 00 00 11 00 00 00 04
0x00000070 00 00 00 00 00 00 00 01 00 00 00 00 00 01 00 00
…
…
…
0xFFFFFFF0
v = p[1];
v = *(p+2);
p→0x0000002A
v → 0x0020 v → 0x0020 v → 0x0005
連続したshort型(2バイト)のデータにアクセスしやすいように,
ポインタ変数の加減算の移動単位が⾃動的に2になる仕様!
ポインタの裏話 プログラミング演習A 44

int*に対する操作
int *p = (int *)0x00000028;
v = *p; ++p;
v = *p;
v→0x1A340020
v = p[1];
v = *(p+2);
p→0x0000002C
v→0x00050028 v→0x00050028 v→0x001A0019
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
0x00000000 7F 45 4C 46 01 02 01 06 01 00 00 00 00 00 00 00
0x00000010 00 02 00 12 00 00 00 01 00 01 08 90 00 00 00 34
0x00000020 00 00 1A A4 00 00 01 00 1A 34 00 20 00 05 00 28
0x00000030 00 1A 00 19 00 00 00 06 00 00 00 34 00 01 00 34
0x00000040 00 00 00 00 00 00 00 A0 00 00 00 A0 00 00 00 05
0x00000050 00 00 00 00 00 00 00 03 00 00 00 D4 00 01 00 D4
0x00000060 00 00 00 00 00 00 00 11 00 00 00 11 00 00 00 04
0x00000070
…
00 00 00 00 00 00 00 01 00 00 00 00 00 01 00 00
…
…
0xFFFFFFF0
ポインタ変数の加減算の移動単位が⾃動的に4になる仕様!
連続したint型(4バイト)のデータにアクセスしやすいように,
ポインタの裏話 プログラミング演習A 45

ポインタの番地に対する加減算
int *p = (int *)0x00000028;
++p;
--p;
p += 2;
pの値 → 0x0000002C
pの値 → 0x00000024
pの値 → 0x00000030
C言語の仕様により,自動的にポイン
タの型を考慮し,加減算が実行される
ポインタの裏話 プログラミング演習A 46

配列とポインタの関係
int *p = (int *)0x00000028;
p[0];
0x00000028番地の値
p[1]; 0x0000002C番地の値
*(p+1);
0x0000002C番地の値
p[i] == *(p+i)
配列は加減算付きのポインタへのアクセス
ポインタの裏話 プログラミング演習A 47

ポインタの裏話 プログラミング演習A 48

char *p = (char *)0x00000018;
みたいなコードは
最近⾒かけない
ポインタの裏話 プログラミング演習A 49

実際に実⾏すると
セグメンテーション
フォルトが発⽣
ﾍ⌒ヽﾌ
( ・ω・) そっか、ぬるぽか!
/ ~つと)
ポインタの裏話 プログラミング演習A 50

ポインタの裏話 プログラミング演習A 51

プログラムはOS
から割り当てられた
番地のみ利⽤できる
ポインタの裏話 プログラミング演習A 52

プログラムがどの
番地を利⽤できるか
実⾏するまで不明
ポインタの裏話 プログラミング演習A 53

プログラムを実⾏する流れ
プログラム・データ
a.out
実⾏
コンパイル結果そのもの
通常は0x00010000から
貼付けられる
プログラムの実⾏につれ
サイズが増減する
プログラムがアクセスして
はいけない領域
プログラム・データ
ヒープ
スタック
メモリ空間
0x00000000
0x00010000
実⾏ファイル
サイズ
追加要求
追加要求
0xFFBEC000
※32ビットSPARC上で動作する
Solarisの場合
※状況に応じてアドレスが変わる
参考: プログラムの読み込み (http://docs.oracle.com/cd/E19253-01/819-0391/chapter6-34713/index.html)
ポインタの裏話 プログラミング演習A 54

セグメンテーション違反
(Segmentation Fault)
≒ 許可されない(予期せぬ)
番地への読み書き(バグ)
\ | /
_┌┬┬┬┐_
――┴┴┴┴┴―、 __________
// ∧// ∧ ∧||. \ /
__[//____(ﾟ_//[ ].ﾟДﾟ,,) || _ \__ < ぬるぽを逮捕しにきました
lﾛ|=☆= |ﾛﾛﾟ|■■|■■ OS ■■|| \__________
| ∈口∋¯_l__l⌒l____|___l⌒l___||
¯¯`ー'¯ `ー' `ー' `ー'
ポインタの裏話 プログラミング演習A 55

ポインタの裏話 プログラミング演習A 56

ポインタの番地を
決めるのはOSや
コンパイラの仕事
ポインタの裏話 プログラミング演習A 57

ポインタの番地を
直接指定する
機会は殆ど無い
ポインタの裏話 プログラミング演習A 58

ポインタの番地を正
しくセットしないと
Segmentation Fault
ポインタの裏話 プログラミング演習A 59

ポインタの裏話 プログラミング演習A 60

C⾔語におけるポインタの使い道
1. 配列
• 配列とポインタは等価
2. ⽂字列
• char型の⽂字の特殊な配列として表現される
3. 関数の引数の参照渡し
• 引数の変数の値を関数内で更新して返す場合
4. メモリ領域の動的な確保
• 配列や構造体を必要なサイズだけ確保する
5. 関数ポインタ
• ⾼等テクニックなので説明は省略
ポインタの裏話 プログラミング演習A 61

①配列としての
ポインタ
ポインタの裏話 プログラミング演習A 62

配列を宣⾔するとどうなるか
int data[6] = {0,1,1,0,1,0};
• コンパイラは,以下の処理を⾃動で⾏う
• 6(個) ×4(byte/int)=24 (byte) の記憶領域を予約
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
…
0x00010220 CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
0x00010230 CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
0x00010240 CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
0x00010250 CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
0x00010260 CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
…
…
0xFFFFFFF0
ポインタの裏話 プログラミング演習A 63

配列を宣⾔するとどうなるか
int data[6] = {0,1,1,0,1,0};
• コンパイラは,以下の処理を⾃動で⾏う
• 6(個) ×4(byte/int)=24 (byte) の記憶領域を予約
• (指定された初期化値を確保した記憶領域にセット)
• メモリ領域の先頭の番地をポインタ変数dataにセット
• この例では,int *data = (int *)0x00010234;
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
…
0x00010220 CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
0x00010230 CD CD CD CD 00 00 00 00 00 00 00 01 00 00 00 01
0x00010240 00 00 00 00 00 00 00 01 00 00 00 00 CD CD CD CD
0x00010250 CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
0x00010260 CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
…
…
0xFFFFFFF0
ポインタの裏話 プログラミング演習A 64

このように
配列のメモリ管理は
⾃動で⾏われる
ポインタの裏話 プログラミング演習A 65

配列がポインタであ
ることを意識せずに
data[i]と書ける
ポインタの裏話 プログラミング演習A 66

②⽂字列を表現する
ポインタ
ポインタの裏話 プログラミング演習A 67

⽂字列を宣⾔するとどうなるか
char *msg = "hello";
• コンパイラは⽂字 (char) 配列に⾃動で変換
char str[] = {'h','e','l','l','o',0};
= {0x68,0x65,0x6C,0x6C,0x6F,0};
• ⽂字列の終端を⽰す0が追加される(⽂字列特有の仕様)
• この例では,msg = (char *)0x00010250;
アドレス 0 1 2 3 4 5 6 7 8 9 A B C D E F
…
0x00010220 CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
0x00010230 CD CD CD CD 00 00 00 00 00 00 00 01 00 00 00 01
0x00010240 00 00 00 00 00 00 00 01 00 00 00 00 CD CD CD CD
0x00010250 68 65 6C 6C 6F 00 CD CD CD CD CD CD CD CD CD CD
0x00010260 CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
…
…
0xFFFFFFF0
ポインタの裏話 プログラミング演習A 68

実は””で⽂字列を
使う度に,裏で⽂字
配列が⽣成される
ポインタの裏話 プログラミング演習A 69

printf(“hello!”);
でも⽂字の配列が
メモリ上に確保される
ポインタの裏話 プログラミング演習A 70

③関数への参照渡し
ポインタの裏話 プログラミング演習A 71

関数とは
• C⾔語の関数
• 0個以上の値を引数として受け取る
• 0個または1個の値を戻り値として返す
戻り値の型 関数名 引数1 引数2
double func(double x, double y)
{
return sqrt(x * x + y * y);
}
• 使い⽅
func(x, y)の戻り値: � � �� �
d = func(3, 4); if (func(x, y) < 1)
ポインタの裏話 プログラミング演習A 72

関数から2つ以上
の値を返すには?
func
直交座標系 極座標系
ポインタの裏話 プログラミング演習A 73

陥りやすいダメな例(cf. 確認問題)
#include
#include
void func(double x, double y, double r, double th)
{
}
r = sqrt(x * x + y * y);
th = atan2(y, x);
変数rとthはfunc関数内で
のみ有効.main関数側に
変更が反映されない!
int main()
{
double x = 1, y = 1, r = 0, th = 0;
func(x, y, r, th);
printf("(r, th) = (%f, %f)¥n", r, th);
}
$ ./a.out
(r, th) = (0.00000, 0.00000)
ポインタの裏話 プログラミング演習A 74

関数の呼び出し元の変数の値を更新する
#include
#include
void func(double x, double y, double *r, double *th)
{
*r = sqrt(x * x + y * y); ポインタ変数が指している
}
*th = atan2(y, x);
値を更新する ③
int main()
{
更新したい変数の番地を渡す
double x = 1, y = 1, r = 0, th = 0;
func(x, y, &r, &th);
printf("(r, th) = (%f, %f)¥n", r, th);
}
$ ./a.out
(r, th) = (1.4142, 0.7854)
更新したい変数をポインタに
ポインタの裏話 プログラミング演習A 75
①
②
④

どんなトリックなのか(1/3)
①: double x = 1, y = 1, r = 0, th = 0;
コンパイラは,main関数内でdouble型(8バイト)
の変数,x, y, r, thの値を保持するメモリを予約
1.0: 0x3FF0000000000000
0.0: 0x0000000000000000
②: func(x, y, &r, &th);
※浮動⼩数点のやや
こしい仕様です.気
にしないで下さい.
※対⽐のため,浮動⼩数点を無理
⽮理8バイトで表記しています.
func(
0x3FF0000000000000,0x3FF0000000000000,
0x00010270, 0x00010278);
アドレス
…
0
x
1 2 3 4 5 6 7 8
y
9 A B C D E F
0x00010260 3F F0 00 00 00 00 00 00 3F F0 00 00 00 00 00 00
0x00010270
…
00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
r th
ポインタの裏話 プログラミング演習A 76

どんなトリックなのか(2/3)
③: *r = sqrt(x * x + y * y);
*th = atan2(y, x);
1 � �1 � � 1.4142 …
tan �� 1 � �/4 � 0.7854 …
②によりmain関数の変数r,thのメモリ番地は,
r=0x00010270, th=0x00010278と伝えられている
*r = 1.4142…
*th = 0.7854…
1.4142…: 0x3FF6A09E667F3BCD
0.7854…: 0x3FE921FB54442D18
※浮動⼩数点のややこしい仕様
です.気にしないで下さい.
アドレス
…
0
x
1 2 3 4 5 6 7 8
y
9 A B C D E F
0x00010260 3F F0 00 00 00 00 00 00 3F F0 00 00 00 00 00 00
0x00010270
…
3F F6 A0 9E 66 7F 3B CD 3F E9 21 FB 54 44 2D 18
r th
00010270番地に1.4142…
00010278番地に0.7854…
ポインタの裏話 プログラミング演習A 77

どんなトリックなのか(3/3)
変数r,thの値を格納しているメモリの内容が書き換え
られたので,r = 1.4142…, th = 0.7854…
つまり,main関数が所有している変数の値を,
func関数から直接変更していたことになる
④: printf("(r, th) = (%f, %f)¥n", r, th);
$ ./a.out
(r, th) = (1.4142, 0.7854)
アドレス
…
0
x
1 2 3 4 5 6 7 8
y
9 A B C D E F
0x00010260 3F F0 00 00 00 00 00 00 3F F0 00 00 00 00 00 00
0x00010270
…
3F F6 A0 9E 66 7F 3B CD 3F E9 21 FB 54 44 2D 18
r th
ポインタの裏話 プログラミング演習A 78

関数内で呼び出し元
の変数の値を更新す
るには,ポインタ化
ポインタの裏話 プログラミング演習A 79

参照渡しの有名な例
ポインタの裏話 プログラミング演習A 80

scanf関数は複数の
値の同時読み込みが
可能になっている
ポインタの裏話 プログラミング演習A 81

このような仕様のため
scanf(“%d %d”, &x, &y);
のように&をつける
ポインタの裏話 プログラミング演習A 82

④メモリ領域の
動的な確保
ポインタの裏話 プログラミング演習A 83

メモリを使うには,
OSに割り当てて
もらう必要がある
ポインタの裏話 プログラミング演習A 84

プログラム執筆時点で
要素数が確定している
配列・⽂字列の確保は
コンパイラの仕事
ポインタの裏話 プログラミング演習A 85

プログラムを書いた時
点で必要な要素数が分
からない場合,⼿動で
メモリ確保する必要
ポインタの裏話 プログラミング演習A 86

例えば･･･
ポインタの裏話 プログラミング演習A 87

ワードプロセッサに
何⽂字⼊⼒されるか
分からない
ポインタの裏話 プログラミング演習A 88

受信するメールの
⼤きさが分からない
ポインタの裏話 プログラミング演習A 89

こういう時は･･･
ポインタの裏話 プログラミング演習A 90

400⽂字格納できる⽂字
列⽤のメモリを下さい
「原稿⽤紙をもう⼀枚下さい!」
ポインタの裏話 プログラミング演習A 91

3,487,394バイトの添付
ファイルを保存・閲覧す
るためのメモリを下さい
ポインタの裏話 プログラミング演習A 92

メモリ管理関数の抜粋
• void *malloc(size_t size);
• sizeバイトの連続したメモリ領域を確保し,そのメモリ
領域の先頭の番地を返す
• void *calloc(size_t n, size_t size);
• メモリ領域を0に初期化しながら確保(詳細は省略)
• void *realloc(void *p, size_t size);
• mallocやcallocで確保されたメモリ領域(先頭の番
地がp)のサイズをsizeに拡張・縮⼩し,新しいメモリ
領域の先頭の番地を返す
• char *strdup(const char *str);
• ⽂字列strを格納できるメモリ領域を確保した後,⽂字
列strを新しいメモリ領域にコピーし,
• void free(void *p);
• 上に挙げた関数で確保されたメモリを解放する
ポインタの裏話 プログラミング演習A 93

400⽂字格納できる⽂字
列⽤のメモリを下さい
char *p = (char *)malloc(400);
ポインタの裏話 プログラミング演習A 94

メモリが不要になった
のでお返しします
free(p);
ポインタの裏話 プログラミング演習A 95

ポインタの裏話 プログラミング演習A 96

___
/ \ ｷﾘｯ
/ \ , , /\
/ (●) (●) \
| (__人__) |
\ ` ⌒ ´ ,/
. /⌒~"¯,¯¯〆⌒,ﾆつ
| ,___ﾞ___､rヾｲｿ⊃
| `l¯
. | |
メモリのイメージが
掴めればポインタは
難しくない!
ポインタの裏話 プログラミング演習A 97

ポインタの⽤途は
限られているので
実例を⾒て慣れよ
|¯¯¯¯¯¯¯¯¯¯¯|
| ここでポインタ! |
|___________|
∧∧ ||
( ﾟдﾟ)||
/ づΦ
ポインタの裏話 プログラミング演習A 98

今回扱わなかった内容
• malloc/freeの実例
• ⼆次元配列
• ポインタのポインタ
• constなどの修飾⼦
• 関数ポインタ
• 構造体のポインタ
ポインタの裏話 プログラミング演習A 99