ポインタ②（配列や文字列との関係性） | Programming Place Plus　Ｃ言語編　第３２章

アドレス計算 🔗

配列の各要素のメモリアドレス^📘を調べてみましょう。

#include <stdio.h>

#define SIZE_OF_ARRAY(array)    (sizeof(array)/sizeof(array[0]))

int main(void)
{
    int array[] = {0, 10, 20, 30, 40};

    for (int i = 0; i < SIZE_OF_ARRAY(array); ++i) {
        printf("%d: %p\n", i, &array[i]);
    }
}

実行結果：

0: 002DF7F4
1: 002DF7F8
2: 002DF7FC
3: 002DF800
4: 002DF804

ここで注目すべき点は、各要素のメモリアドレスがそれぞれ 4 ずつ増えていることです。この 4 という値の正体は、sizeof(int) です。そのため、sizeof(int) が 4以外の環境であれば結果は変わりますが、とにかく、int型の大きさ分ずつずれていきます。

これは、配列の特徴の１つです。配列は、各要素がメモリ上で連続的に隙間なく並ぶことが保証されています。この性質を利用して、配列の要素数を調べる方法があります。

#include <stdio.h>

int main(void)
{
    int array[5] = {0, 10, 20, 30, 40};

    printf("%d\n", &array[5] - &array[0]);
}

実行結果：

このように、同じ配列の要素を指すポインタ同士を減算すると、２つのポインタの間にある要素数が取得できます。ポインタの値はメモリアドレスですから、単純に減算すると「0x002DF808 - 0x002DF7F4」のような計算になって、20 が得られそうですが、そうはならないということです。

なお、異なる配列を指しているポインタ同士での減算は、未定義の動作^📘となるので注意してください。

ポインタ同士の減算で得られる値は、ptrdiff_t型です。ptrdiff_t型の大きさは、環境によって異なる可能性がありますが、符号付き整数型^📘であることは確かです。

ptrdiff_t型を printf関数や scanf関数で使用する際には、“%td” という変換指定を使います。

#include <stdio.h>

int main(void)
{
    int array[5] = {0, 10, 20, 30, 40};

    printf("%td\n", &array[5] - &array[0]);
}

実行結果：

ところで、「&array[5] - &array[0]」という式は、配列の末尾を超えたところを使っているように見えます。array の要素数は 5 なので、添字に 5 を使うのは不正でないのでしょうか。

これは実は問題ありません。ポインタ同士で減算をおこなう際には、配列の末尾要素の１つ後ろまでは使っても良いことになっています。

ただし、array[5] の位置に有効な要素はありませんから、その要素を参照しようとする行為は未定義の動作^📘です。

また、ポインタの加算も有効です。

#include <stdio.h>

#define SIZE_OF_ARRAY(array)    (sizeof(array)/sizeof(array[0]))

int main(void)
{
    int array[] = {0, 10, 20, 30, 40};

    for (int* p = &array[0]; p != &array[SIZE_OF_ARRAY(array)]; ++p) {
        printf("%d\n", *p);
    }
}

実行結果：

ポインタ変数に対するインクリメント操作では、メモリアドレスが +1 されるのではなく、sizeof(指し示す先の型) 分だけ加算されます。デクリメント操作も同様ですし、2以上の加算や減算でも同様です。このため、配列の要素を指すポインタをインクリメントすると、「次の要素へ」という感覚で扱えます。

ところで、ポインタ変数に対するインクリメントやデクリメントに関して、優先順位の問題があります。

*p++;

これは、ポインタ変数がインクリメントされてから間接参照^📘するのか、間接参照した先にある変数をインクリメントするのか、という問題です。

この場合は「ポインタ変数がインクリメントされてから間接参照される」が正解ですが、非常に分かりづらいです。コンパイラが優秀でなかった時代には、このような書き方をすると、効率が良くなることもあったようですが、いまや時代錯誤です。現代的には、こういう小手先の最適化は避けて、読みやすさを重視すべきです。

たとえば、次のように ( ) を補うと明確です。

*(p++);    // p をインクリメントしてから、間接参照
(*p)++;    // 間接参照した先にある値をインクリメント

配列とポインタの関係性 🔗

当たり前といえば当たり前のことですが、「配列とポインタはまったく異なるものです」。一見、どちらでも同じように動作する場面があるため混乱している人もいるようですが、明確に異なるものであるという認識をもつことが大切です。

まず、配列を使ったサンプルプログラムを挙げます。

#include <stdio.h>

#define SIZE_OF_ARRAY(array)    (sizeof(array)/sizeof(array[0]))

int main(void)
{
    int array[] = {0, 10, 20, 30, 40};

    for (int i = 0; i < SIZE_OF_ARRAY(array); ++i) {
        printf("%d\n", array[i]);
    }
}

実行結果：

このプログラムは、ポインタを使って、次のように書き換えることが可能です。

#include <stdio.h>

#define SIZE_OF_ARRAY(array)    (sizeof(array)/sizeof(array[0]))

int main(void)
{
    int array[] = {0, 10, 20, 30, 40};
    int* p = &array[0];

    for (int i = 0; i < SIZE_OF_ARRAY(array); ++i) {
        printf("%d\n", p[i]);
    }
}

実行結果：

ポインタ変数p を追加し、配列の先頭要素のメモリアドレスで初期化しています。printf関数を呼び出す際には、array[i] の代わりに、p[i] と記述しましたが、先ほどの配列版プログラムとまったく同じ実行結果になります。

配列とポインタが同じものである錯覚する原因の１つがここにあります。実のところ、以下の２つは本当に同じ意味です。

printf("%d\n", array[i]);
printf("%d\n", p[i]);     // ただし p は array の先頭要素を指すポインタ

しかし、配列＝ポインタではありません。

上記の２つの文が同じ意味になる理由は、「式の中で array のような配列の名前が現れたときは、暗黙的に、その配列の先頭を指すポインタに置き換わる」からです。

たとえば、array[0] = 10; のように書いたとき、array の部分がポインタに置き換わり（仮に p という名前とします）p[0] = 10; と同じになります。

func(array); であれば、func(p); のように置き換わって、ポインタを関数に渡していることになります。第２５章で配列を説明したとき、配列を引数や戻り値には使えないと書きましたが、その理由がこれです。配列は配列のままでは扱えず、関数に渡す際にも、関数から戻される際にも、ポインタに置き換えられてしまうのです。この話題については、次章であらためて説明します。

もう１つ例を見ておきましょう。

int array[5];
int* p;

p = array;    // p = &array[0]; と同じ

配列がポインタに変換されるので、このコードのように、ポインタ変数に配列を代入するような式が書けます。「ポインタ変数 = 配列」という代入式は適切には思えませんが、これは問題ないですし、非常によく使うコードですらあります。

ところで、ポインタ変数 p が array の先頭を指しているのなら、array[i] と p[i] は同じです。では、array[i + 5] と p[i + 5] ならどうでしょう？

これもやはり同じになります。添字演算子は配列に対して使っても、（配列を指している）ポインタに対して使っても同じ結果になります。添字演算子の “添字” という響きから、配列に対してしか適用できないように思えるかもしれませんが、そうではないということです。

配列はポインタに置き換えられているのだから、添字演算子の適用対象はむしろポインタであるといえます。

ところで、アドレス計算の話のところで説明したように、ポインタ変数に対する加算は、指し示す先にある要素の型の大きさの分だけ加算されます。ですから、p が配列の要素を指しているのなら、p + i は、p から i要素分だけ先の要素を指します。それはつまり、配列の i番目の要素ということですから、p + i と p[i] は同じです。

printf("%d\n", p[i]);     // ただし p は array の先頭要素を指すポインタ
printf("%d\n", *(p+i));   // 上と同じ意味

ですから、添字演算子を使わなくても、*(p+i) のような方法で書くことも可能です。しかし明らかに面倒ですし素直ではありません。

【上級】a[3] と *(a+3) が同じということは、*(3+a) も同じ意味である訳です。そのため、実は a[3] は 3[a] とも書けます。そんなことをする理由はまったくありませんが。

文字列 🔗

突然ですが、“abcde” のような文字列リテラルは、何型なのでしょうか？

これもよく勘違いされているようですが、文字列リテラルの正体は char型の配列です。char* のようなポインタ型ではありません。

【上級】C++ の場合は const char型の配列です。

文字列リテラルが配列であることは、次のコードからも確認できます。

printf("%zu\n", sizeof("abcde"));

この出力結果が 6 になることから分かります（末尾に ‘\0’ があるので 5 ではありません）。もし文字列リテラルがポインタであり、ポインタ変数の大きさが 32ビットの環境であれば、出力結果は 4 になるはずです。

文字列リテラルがポインタ型であるという勘違いが生まれる原因の１つは、次の２つがともに有効であることでしょう。

char str[] = "abcde";
char* str = "abcde";

この２つの文の初期値は同じように見えるかもしれませんが、意味は違います。

ポインタ変数str を初期化する際に現れた “abcde” は、メモリ上のどこかにある文字列リテラルです。文字列リテラルが char型の配列であり、“abcde” のような要素を持っている以上、メモリのどこかにあるはずなのです。

一方、配列の str を初期化する際に現れた “abcde” は、「配列の各要素に与える初期値」というだけの存在です。どこか別のところに、“abcde” があるわけではなく、今まさに、配列の要素に与えようとしている文字の並びにすぎません。次の２つが同じ意味だということを思い出すと、言わんとすることが分かるでしょうか？

char str[] = "abcde";
char str[] = {'a', 'b', 'c', 'd', 'e', '\0'};

ポインタ変数 str の初期値 “abcde” は、char型の配列ですが、「配列とポインタの関係性」のところで説明したとおり、配列は暗黙的にポインタに変換されます。そのため、char型のポインタ変数の初期値として、文字列リテラルを使えます。

これはもう少し言い換えると、メモリ上のどこかにある文字列リテラル “abcde” の先頭を指すポインタに変換され、そのポインタを初期値としています。

配列版の str と、ポインタ版の str のイメージは次の図のようになります。

この図が示すように、配列版とポインタ版は明確に異なります。

const型修飾子 🔗

文字列リテラルは char型の配列ですから、書き換える行為ができてしまいます。しかし、文字列リテラルを書き換えようとする行為は、未定義の動作^📘とされていますから、このようなことはしてはいけません。

"abcde"[2] = 'x';  // コンパイルできるが、未定義動作

【上級】C++ の場合は、コンパイルエラーになります。これは、文字列リテラルが const char型の配列に変更されたからです。

このように、文字列リテラルは不親切な仕様になっていますが、もし書き換えることが不適切なのであれば、明示的にコンパイルエラーになってほしいところです。そうすれば間違いようがありませんから。

文字列リテラルに関しては無理ですが、const型修飾子 (const type qualifiers) を使うと、変数の値の書き換えを明示的に禁止できます。

const 型名 変数名 = 初期値;

この後、変数num になんらかの値を代入しようとすると、コンパイルエラーになります。つまり、const型修飾子は、その変数の値を「書き換え不可とする」という意味があります。

【C++ プログラマー】Ｃ言語では、const を付加して宣言された変数は、書き換えられない変数という扱いであり、定数とは異なります。一方、C++ では定数を意味しますから、C++プログラマーは、両言語で意味が異なることに注意してください。たとえば、Ｃ言語では、const付きの変数を、配列を宣言する際の要素数の指定に使うことができません（C++編【言語解説】第１５章）。

実際のプログラムで確認してみましょう。

#include <stdio.h>

int main(void)
{
    const int num = 100;

    num = 0;  // コンパイルエラー
    printf("%d\n", num);
}

const は、バグの少ない安全なプログラムを書くために大きな助けになる優れた機能です。初期値として与えた値を変更するべきでないときには、いつも const を付けて変数宣言する習慣は悪くありません。

const は、static や extern のような、ほかの修飾子と同時にも使えます。記述の順番も自由です。

【C++ プログラマー】グローバル変数に const を付加した場合、Ｃ言語では普段のルールどおり、外部結合^📘になりますが、C++ では内部結合^📘になります（C++編【言語解説】第１５章）。そのため、Ｃ言語でも C++ でも同じ意味を持たせるためには、外部結合にしたいときはいつも extern を補い、内部結合にしたいときはいつも static を補うようにします。

ポインタ変数を const付きで宣言するときには注意が必要です。保持する値を書き換えられないようにするには、次のように宣言します。

int* const p = 初期値;

const型修飾子を書く位置に注意が必要です。ポインタ変数の値を書き換えられないようにするには、「*」よりも右側に const を置くのだと理解してください。

int num = 100;
int* const p = &num;  // p が保持するメモリアドレスを変更できない
*p = 200;  // OK
p = NULL;  // コンパイルエラー

「*」よりも左側に const を置くと、ポインタ変数が指し示す先にあるものを変更できない]{.s}、という意味になります。

int num = 100;
int num2 = 200;
const int* p = &num;  // p が指し示す先にあるものを変更できない
p = &num2;  // OK
*p = 0;     // コンパイルエラー

次の２つの文は同じ意味になることも注意してください。

const int* p = 初期値;
int const* p = 初期値;

ともかく、const と * の位置関係が重要であって、それ以外の表記（int など）の登場順序や、空白の有無などに惑わされないようにしましょう。

なお、これらの２種類の const型修飾子を同時に使用することも可能です。この場合、２つの特性が同時に適用されますから、ポインタ変数自体を書き換えできませんし、ポインタが指し示す先にあるものも書き換えできません。

int num = 100;
const int* const p = &num;  // p が保持するメモリアドレスも、指し示す先にあるものも変更できない
*p = 200;  // コンパイルエラー
p = NULL;  // コンパイルエラー

また、const付きのポインタを、const が付いていないポインタ変数へ代入することは危険を伴う行為です。コンパイルエラーにはならないのですが、たいていのコンパイラは警告を発するはずです。

int num = 100;
const int* cp = &num;
int* p = cp;  // 大丈夫？

【上級】C++ では、constポインタを const でないポインタに暗黙的に型変換しようとするコードは、コンパイルエラーになります。

int* p = (int*)cp; のように、キャスト^📘を行えば許可されますが、それによって正しさが保証されるわけではありません。次のコードはキャストで正当性を主張していますが、*p = 200; が安全とはいえません。

const int num = 100;
const int* cp = &num;
int* p = (int*)cp;  // 大丈夫？
*p = 200;     // p が指し示す先は const int だが書き換えていいのか？

配列とポインタの実用上の違い 🔗

以下の２つの文の意味は異なる訳ですが、実用上の違いはあるのでしょうか？

char str[] = "abcde";
char* str = "abcde";

まず、配列版は要素を書き換えられますが、ポインタ版はできません（してはいけません）。

#include <stdio.h>

int main(void)
{
#if 1
    char str[] = "abcde";
#else
    char* str = "abcde";
#endif

    str[2] = 'x';  // 配列版では OK。ポインタ版ではコンパイルできるが未定義の動作
    puts(str);
}

実行結果：

abxde

配列版ならば、このプログラムは問題なく実行できますが、ポインタ版だと未定義の動作^📘です。

一方で、ポインタ版の方は、指し示す先を切り替えることが可能です。

#include <stdio.h>

int main(void)
{
#if 0
    char str[] = "abcde";
#else
    char* str = "abcde";
#endif

    str = "xyz";  // 配列版ではコンパイルエラー。ポインタ版では OK
    puts(str);
}

実行結果：

xyz

こちらは配列版だとコンパイルエラーになります。配列版での以下の文、

str = "xyz";

これは、str も “xyz” も配列なので、それぞれポインタに変換されます。そのため、以下のように書いたことと同じです。

&str[0] = &"xyz"[0];

これはコンパイルできないわけですが、その理由は、代入の左辺側が何かを受け取れるような形ではないからです。普通、配列の先頭要素へ何かを代入するときには、

str[0] = 100;

のように書きます。このとき、&演算子は付いていませんが、先ほどの形では &演算子が付いてしまっています。

このように、配列が先頭要素を指すポインタに置き換えられるというルールのため、配列で表現された文字列の内容が一致しているか調べる際に、等価演算子^📘が使えません。代わりに、strcmp関数を使います。

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

int main(void)
{
    char str[] = "abcde";

    if (str == "abcde") {
        puts("==演算子による比較");
    }
    if (strcmp(str, "abcde") == 0) {
        puts("strcmp関数による比較");
    }
}

実行結果：

strcmp関数による比較

配列である str に対して等価演算子を使うと、等価演算子の左辺も右辺もポインタに変換されますから、次のように書いたのと同じことになります。

if (&str[0] == &"abcde"[0])

変数str のメモリアドレスと、文字列リテラル”abcde” のメモリアドレスは異なるため、この if文は絶対に真になりません。目的はメモリアドレスが一致しているかどうかを調べることではなく、文字列の内容が一致しているかどうかを調べることですから、これは間違っています。

そこで strcmp関数を使います。strcmp関数は２つの文字列の先頭から１文字ずつ順番に比較処理をおこなうので、これで正しい比較になります。

もし、str がポインタであっても、strcmp関数を使えば文字列の内容を比較できます

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

int main(void)
{
    char* str = "abcde";

    if (str == "abcde") {
        puts("==演算子による比較");
    }
    if (strcmp(str, "abcde") == 0) {
        puts("strcmp関数による比較");
    }
}

実行結果：

strcmp関数による比較

ポインタの場合に等価演算子を使って比較した場合の結果には保証がありません。ポインタ変数str の初期値として与えた “abcde” と、if文のところに書いた “abcde” が、メモリ上の同じものを指すようにコンパイルされていれば if文は真になります。しかし、文字列リテラルの内容が同一だからといって、メモリ上で同じものを共有する保証はありません。

文字列の内容を後から書き換えるのであれば、配列を使うのが適切です。ポインタでは、文字列リテラルを指し示すので、書き換える行為は未定義の動作^📘となり不適切です。

文字列の比較をおこなうときには、文字列のメモリアドレスの一致を知りたいのか、文字列の内容の一致を知りたいのかをきちんと区別してください。

文字列の長さ 🔗

ある文字列に含まれている文字数を知りたい場面はよくあります。配列として宣言された文字列変数であれば、sizeof演算子を利用することが考えられます。

#include <stdio.h>

int main(void)
{
    char str[] = "abcde";

    printf("%zu\n", sizeof(str)-1);
}

実行結果：

文字列は、末尾の ‘\0’ の分まで確保されているので、sizeof演算子の返す値から -1 する必要があります。

str がポインタになっている場合に sizeof演算子を使うと、単にポインタ１つの大きさになるだけなので、文字数の取得をしていることにはなりません。32ビット環境であれば、おそらく 4 を返すことでしょう。

文字数を知るための汎用的な手段は、strlen関数を使うことです。strlen関数を使うには、<string.h> をインクルードします。

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

int main(void)
{
    char str[] = "abcde";

    printf("%zu\n", strlen(str));
}

実行結果：

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

int main(void)
{
    char* str = "abcde";

    printf("%zu\n", strlen(str));
}

実行結果：

strlen関数は、実引数で指定した文字列の文字数を、size_t型で返します。strlen関数は ‘\0’ までの文字数をカウントして返します。

"abc\0de";

このように、間に ‘\0’ が挟み込まれているような文字列を渡すと、全体の文字数を返してくれないことには注意が必要です。

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

int main(void)
{
    printf("%zu\n", strlen("abc\0de"));
}

実行結果：

複合リテラル 🔗

第２６章では構造体に対する複合リテラルを解説しましたが、ここでは配列に対する複合リテラルを解説します。

【C89/95 経験者】この機能は C99 で追加されたものです。

基本的には構造体の場合と同じで、次の構文によって、名前のない配列型のリテラルを記述できます。

(型名){初期化子並び}

「型名」には配列型の名前を入れます。要素数を指定しなかった場合は「初期化子並び」に記述した初期値の個数で決定されます。文字の配列の場合は、「初期化子並び」のところに文字列リテラルを記述できます。また、要素指示子（第２５章）を使っても構いません。

なお、可変長配列^📘（第２５章）には使えません。

複合リテラルを関数内で使った場合、生成されたオブジェクト^📘は、記述した位置を囲むブロック内でだけ有効であり、自動記憶域期間^📘（第２２章）をもちます。一方、関数の外側で使った場合は、静的記憶域期間^📘（第２２章）をもちます。

複合リテラルによって生成されたオブジェクトは配列型ですから、その値を代入する際には、ポインタ型に変換されます。そのため、変数に受け取るのならポインタ型で受け取らなければなりません。

#include <stdio.h>

int main(void)
{
    int* pa;
    
    pa = (int[]){0, 1, 2, 3};

    for (int i = 0; i < 4; ++i) {
        printf("%d\n", pa[i]);
    }
}

実行結果：

複合リテラルによって作られた配列は、どうあってもポインタを経由して扱うことになるので、このサンプルプログラムのように、後から配列の要素数が必要になるケースでは不便です。要素数を表す記号定数^📘をつくった方がいいかもしれません。

関数の実引数に渡す例としては、たとえば次のようになります。

#include <assert.h>
#include <stdio.h>

int max_element(const int* array, size_t size)
{
    assert(array != NULL);
    assert(size >= 1);

    int max = array[0];

    for (size_t i = 1; i < size; ++i) {
        if (max < array[i]) {
            max = array[i];
        }
    }
    return max;
}

int main(void)
{
    printf("%d\n", max_element((int[]){4, 7, 2, -1, 3}, 5));
}

実行結果：

練習問題 🔗

問題①　配列に文字列を代入するとき、strcpy関数を使わないといけない理由を説明してください。

問題②　次の４つの printf関数の出力結果をそれぞれ答えてください。

char str1[] = "abcd";
char* str2 = "abcd";

printf("%zu\n", sizeof(str1));
printf("%zu\n", strlen(str1));
printf("%zu\n", sizeof(str2));
printf("%zu\n", strlen(str2));

問題③　strlen関数と同じことをする処理を書いてください（関数化する必要はありません）。

問題④　次のように定義された配列があります。

int table[] = {0, 10, 20, 30, 40, 50, 60, 70};

この配列table のメモリアドレスを printf関数の “%p” 変換指定子を用いて調べたところ、0x0013D684 でした。このとき、配列table の末尾の要素70 のメモリアドレスがいくつであるか答えてください。ただし、sizeof(int) は 4 であるものとします。

解答ページはこちら。

参考リンク 🔗

『Ｃ言語ポインタ完全制覇』
- ポインタの基礎から応用まで、徹底的に解説
Programming Place Plus　Ｃ言語編　参考書籍
- 当サイトの参考書籍一覧ページ。Ｃ言語に関する書籍を多数紹介
Programming Place Plus　Ｃ言語編　リンク集
- 当サイトの参考Webサイト集。Ｃ言語の全般的な学習に有益なサイトを紹介

更新履歴 🔗

’2023/3/5
- コーディング規約を統一（要素を書き並べるとき { の直後と、} の直前に空白を入れない）
’2023/2/12
- 初出の重要用語に英語表記を併記
’2023/2/5
- コーディング規約を統一（for、if などの () の前後の空白の空け方）
’2023/2/4
- コーディング規約を統一（実引数がある関数呼び出しの ( の直後、) の直前に空白を入れない）
’2021/12/11
- main関数から return 0; を削除（Ｃ言語編全体でのコードの統一）

≪さらに古い更新履歴≫

’2020/3/14
- 「配列とポインタの関係性」の項の解説を見直し
’2019/7/25
- 解説のベースを C99 に上げる対応
  - 「複合リテラル」の項を追加
’2019/7/23
- 解説のベースを C99 に上げる対応
  - ローカル変数の宣言を、ブロックの先頭以外の位置でもおこなう
’2019/7/18
- 解説のベースを C99 に上げる対応
  - コメントを // 形式で統一
’2019/7/15
- 解説のベースを C99 に上げる対応
  - ループ制御変数を for文の初期設定式で宣言するように修正
’2019/7/14
- 解説のベースを C99 に上げる対応
  - 「C99 (printf関数、scanf関数での ptrdiff_t型の扱い)」の項を削除。本文へ入れ込んだ
’2019/7/9
- 解説のベースを C99 に上げる対応
  - size_t型の出力に “%zu” を使うように修正
’2018/6/1
- 第３８章から練習問題④を移動してきた。
’2018/5/14
- 章のタイトルを変更（「ポインタ②　基礎」->「ポインタ②　配列や文字列との関係性」）
’2018/4/5
- Visual Studio 2013 の対応終了。
’2018/4/2
- 「VisualC++」という表現を「Visual Studio」に統一。
’2018/3/9
- 「const修飾子」の項に、const のポインタに関する説明を追加。
’2018/3/8
- 全面的に文章を見直し、修正を行った。
  「const修飾子」の項を追加（第３７章から一部切り出してきた）
’2018/3/7
- 「*演算子」を「間接演算子」に統一。
’2018/2/22
- 「サイズ」という表記について表現を統一。型のサイズ（バイト数）を表しているところは「大きさ」、要素数を表しているところは「要素数」。
’2018/2/21
- 文章中の表記を統一（bit、Byte -> ビット、バイト）
’2018/2/1
- Ｃ言語編全体で表記を統一するため、「“%d”フォーマット」のような表現に「変換指定子」を使うように改めた。
’2017/4/29
- ptrdiff_t型についての記述を追加。
’2015/12/27
- SIZE_OF_ARRAYマクロの定義を修正。
’2015/8/25
- 各サンプルプログラムで、配列の要素数をマクロで計算するスタイルに修正。
’2013/8/11
- 「*p++;」を分割するコード例が不適切だったので削除。
’2012/3/31
- 「文字列の長さ」のサンプルプログラム中で、include するヘッダの名前が間違っていたのを修正。
’2009/11/18
- 新規作成

前の章へ　（第３１章　ポインタ①（概要））

次の章へ　（第３３章　ポインタ③（引数や戻り値への利用））

Ｃ言語編のトップページへ

Programming Place Plus のトップページへ

はてなブックマークに保存	Pocket に保存	Facebook でシェア
X でポスト／フォロー	LINE で送る	noteで書く
RSS	管理者情報	プライバシーポリシー

このページの概要 🔗

アドレス計算 🔗

配列とポインタの関係性 🔗

文字列 🔗

const型修飾子 🔗

配列とポインタの実用上の違い 🔗

文字列の長さ 🔗

複合リテラル 🔗

練習問題 🔗

参考リンク 🔗

更新履歴 🔗