C/C++演習「知っとけ！メモリ操作」

 詳細を以下のソースコード内にコメントとして記述しました。繰り返しますが C言語のstaticキーワードは多義的でわかりにくい のでここで理解して覚えてください。

#include <stdio.h>

/* nval -------------------------------------------------------
【ファイル内外グローバル変数】です。一般的には"グローバル変数"と
呼ばれます。関数の外にてstaticなしで定義されているこの変数は、
他のソースファイルからもアクセス可能です。他のソースファイルから
アクセスする際は、そのソースファイルにて、以下のextern宣言が必要
となります。
extern char nval;
-------------------------------------------------------------*/
char nval = 'w';

/* sval -------------------------------------------------------
【ファイル内グローバル変数】です。一般的には"static変数"と呼ばれます。
関数外でstaticで定義されているこの変数は、そのソースファイル内から
のみアクセス可能です。
-------------------------------------------------------------*/
static int sval;

/* add() ------------------------------------------------------
【ファイル内外グローバル関数】です。一般的には"グローバル関数"と
呼ばれます。staticなしで定義されているこの関数は、他のソースファイル
からも呼び出し可能です。他のソースファイルから呼び出す際は、その
ソースファイルにて以下のプロトタイプ宣言が必要となります。
int add(int a1, int a2);
自身のソースファイル内にて、関数定義の前に呼び出す場合も、上の
プロトタイプ宣言が必要です。
-------------------------------------------------------------*/
int add(int a1, int a2)
{
  /* a1, a2, sum ----------------------------------------------
  【関数内ローカル変数】です。単に"ローカル変数"または"自動変数"
  とも呼ばれます。変数定義以降の関数内でアクセス可能です。
  -----------------------------------------------------------*/
  int sum;
  sum = a1 + a2;
  return sum;
}

/* divide() ---------------------------------------------------
【ファイル内外グローバル関数】"グローバル関数"です。
add()と同様です。
-------------------------------------------------------------*/
int divide(int d1, int d2)
{
  if(d2 == 0){
    /* alter -------------------------------------------
    これも【ローカル変数】です。
    変数定義以降のブロック内("{"～"}")でアクセス可能です。
    ここでは49行～55行の間でアクセス可能です。
    --------------------------------------------------*/
    int alter = 1; // anyway, other than 0...
    return d1 / alter;
  }else{
    return d1 / d2;
  }
}

/* countup() --------------------------------------------------
【ファイル内ローカル関数】です。一般的には"static関数"と呼ばれます。
staticで定義されているこの関数は、自身のソースファイルからのみ呼び
出しが可能です、他のソースファイルからの呼び出しは不可です。自身の
ソースファイルにて、関数定義の前に呼び出す場合、以下のプロトタイプ
宣言が必要です。
static void countup();
-------------------------------------------------------------*/
static void countup()
{
  /* counter -------------------------------------------------
  【関数内static変数】です。変数定義以降の関数内で利用可能です。
  ここでの"static"は"静的"という意味になります。つまり、
  この関数が終わってもその領域は残ります。詳細は後述します。
  -----------------------------------------------------------*/
  static int counter;
  counter++;
  printf("counter=%d\n", counter);
}

void main()
{
  printf("nval=%c, sval=%d\n", nval, sval);
  countup();
  /* x,y,z ----------------------------------------------
  これも【関数内ローカル変数】です。a1, a2, sumと同様です。
  -------------------------------------------------------*/
  int x = 30;
  int y = 5;
  int z;
  z = add(x, y);
  printf("added=%d\n", z);
  z = divide(x, y);
  printf("divided=%d\n", z);
  countup();
}

 関数の外にある変数、つまりファイル内外グローバル変数、ファイル内グローバル変数は、スコープの観点から近年ではその使用はあまり奨励されません。しかし組込みソフトウェアの分野等ではよく使用されます。よってその特性を理解しておく必要があります。

 自身のソースファイル内からしか呼ばれない関数は必ずstaticをつけてstatic関数とするべき です。スコープの意義である「不必要な情報は外に見せない」といった設計がソースの可読性や保守性を各段に向上させます。これはJava言語などのprivateと同じ意味合いです。

 ここで説明した通りC言語のstaticには「プライベート」と「静的」という２つの意味合いがあります。 ピンと来ない方もいると思いますが慣れて覚えていくしかありません。なお「静的」については以降のライフサイクルの節で説明します。

• グローバル変数、static変数 : nval, sval, counter
   プログラム起動時に領域が確保され、プログラム終了時に領域が解放されます。つまり、プログラムが動いている間その領域と値は保証されます。関数内static変数counterも同様で、その関数が終了してもその領域と値は保証されます。また、これらの変数は明示的に初期化していればその値が、初期化していなければ0x00が設定されます。初期化はいずれもプログラムの起動時に1度だけ実施されます。
  
  
• ローカル変数 : a1, a2, sum, alter, x, y, z
   その変数を定義している関数もしくはブロック{～}が終了した時点で領域と値は保証されなくなります。a1, a2といった引数（アーギュメント）は呼び出し側で設定された引数（パラメータ）の値がコピーされますが、それ以外の変数は 明示的に初期化しないとその値は不定です。 たとえば、たまたま0x00が入っているかもしれませんし、それ以外の任意の値（通称ゴミ）が入っているかもしれません。よって、関数内ローカル変数はプログラマが初期化してあげる必要があります。ローカル変数の初期化忘れが原因で発生する障害はC/C++の開発現場では非常に多い ので注意です。

 コーディングします。viに慣れなければgedit,leafpadなどの適当なテキストエディタを使ってください。

$ vi valiables.c

 コンパイル・リンクします。

$ gcc -o valiables valiables.c

 生成された実行可能プログラム（valiables）を確認します。

$ ls
valiables valiables.c

 valiablesを実行します。Linuxでは通常カレントディレクトリ./に実行パスが張られていないので、以下の様にカレントディレクトリ./を頭につけて実行します。

$ ./valiables 
nval=w, sval=0
counter=1
added=35
divided=6
counter=2
$

 counterの値は2つとも予測通りでしたか？その他の値も予測通りでしたか？

#include <stdio.h>

void main()
{
  int a = 1;
  int *p;  // pというポインタ変数を定義
  p = &a;  // pにaのアドレスを代入
  *p = 2;  // pの指し示す先(つまりa)に2を代入
  printf("a=%d\n", a);
}

$ gcc -o pointer pointer.c
$ ./pointer 
a=2
$ 

 ポインタを理解するためには、ソースコードの各ステップごとに、その変数がメモリに配置された状態をイメージすることが大切です。

• int a = 1;
   この式が実行されると、aという名前のintの値の格納領域が任意のアドレスに確保されます。アドレスの実際の値をプログラマは気にする必要はありませんが、ここでは説明のために0x30000番地としておきます。この文では代入も実施しているのでその領域に1が設定されます。

• int *p;
   この式が実行されると、pという名前のintのアドレスの格納領域（つまりポインタ） が任意のアドレスに確保されます。アドレスの実際の値をプログラマは気にする必要はありませんが、ここでは説明のために0x30004番地としておきます。この文では代入も実施していないのでその領域の値は不定です。

• p = &a;
   この式が実行されると、aの&つまり aアドレス （この例では0x30000）がpに設定されます。

• *p = 2;
   この式が実行されると、pの指し示す先 つまりaに2が設定されます。

  この状態は以下のような図で示されることも多いです。

  int a = 1;
  int *p;  // pというポインタ変数を定義
  p = &a;  // pにaのアドレスを代入
  *p = 2;  // pの指し示す先(つまりa)に2を代入

int a = 1;
int *p;  // pというポインタ変数を定義
p = &a;  // pにaのアドレスを代入
*p = 2;  // pの指し示す先(つまりa)に2を代入

#include <stdio.h>

// 機能："a=2" と出力する。
void func1()
{
  int a = 1;
  int *p = &a; // a を &a と修正
  *p = 2;
  printf("a=%d\n", a); 
}

// 機能："a=2" と出力する。
void func2()
{
  int a = 1;
  int *p = &a;
  *p = 2; // p を *p と修正
  printf("a=%d\n", a);
}

// 機能："*p=2" と出力する。
void func3()
{
  int a;  // この行を追加
  int *p;
  p = &a; // この行を追加
  *p = 2;
  printf("*p=%d\n", *p); 
}

void main()
{
  func1();
  func2();
  func3();
}

$ gcc -o pointer_bug  pointer_bug.c 
$ ./pointer_bug 
a=2
a=2
*p=2
$ 

 func1(),func2()はソースが設問のままだとgccではコンパイルエラーとなり実行することができません。しかし、func3()は設問のままでもコンパイル・リンクが正常終了し、プログラムを実行することができてしまいます。

 修正前のfunc3()を実行すると、今回の環境では"Segmentation fault (コアダンプ)"とメッセージを吐いてプログラムが異常終了します。これはポインタ変数pを不定値のまま参照しているためです。これが メモリ不正アクセス です。ただし同じようなケースでも環境によってはすぐには異常終了せず、まったく関係のない別の場所で突然異常終了することがあります。

 メモリ不正アクセスが発生すると、その原因究明に大変苦慮する場合があります。その詳細と対策については後述します。

#include <stdio.h>

// 機能：a と b を足して c に設定する（バグ修正前）
void add_bug(int a, int b, int c)
{
  c = a + b;
}

// 機能：a と b を足して c に設定する（バグ修正後）
void add(int a, int b, int *c)
{
  *c = a + b;
}

void main()
{
  { // バグ修正前の呼び出し
    int x = 2;
    int y = 3;
    int z = 0;
    add_bug(x, y, z);
    printf("add_bug():z=%d\n", z); // "z=5"を期待!
  }
  { // バグ修正後の呼び出し
    int x = 2;
    int y = 3;
    int z = 0;
    add(x, y, &z);
    printf("add():z=%d\n", z); // "z=5"を期待!
  }
}

$ gcc -o call_by_value call_by_value.c
$ ./call_by_value
add_bug():z=0
add():z=5
$ 

 説明のため、上のソースファイルではバグ修正前の関数とその呼び出し処理を残しています。

• 期待と違っていた理由
   20行目の変数int zと、4行目のadd_bug()の引数int cは、 別領域に存在する別変数 です。よってadd_bug()の内部でいくら頑張って変数cの値を更新しても、呼び出し側の変数zの値を変更することができません。それが理由です。
  
  

 以降にバグ修正後のソースを説明します。関数の中で呼び出し元の変数の値を変更するには、その変数の値でなくその変数のアドレス&zを関数に渡す必要があります。

 int z = 0;
 add(x, y, &z);

 呼び出される関数はそのアドレスをポインタint *cで受け取り、関数の中の処理でポインタcの指し示す先つまり*cを更新します。*cは呼び出し元のzなので、これによって呼び出し元の変数の値を更新することが可能となります。

void add(int a, int b, int *c)
{
  *c = a + b;
}
void main()
{
  int x = 2;
  int y = 3;
  int z = 0;
  add(x, y, &z);
}

 イメージが浮かばなかったら図を書くなりして確認してください。以下は上の*c = a + b;が実行された直後のメモリイメージです。破線はここではスコープの境界とします。ポインタを使えばスコープの境界を越えた変数にアクセス可能なのです。

 このようにポインタは関数を介すなどして変数の値を変更する場合によく利用されます。

#include <stdio.h>

#define VALUES_A_LEN 128

struct Values
{
  int a[VALUES_A_LEN];
  float b;
  double c;
};

// 機能：struct Valuesのメンバの値を標準出力します。
void print_values(const struct Values *s)
{
  for(int i = 0; i < VALUES_A_LEN; i++){
    printf("a[%d]=%d ", i, s->a[i]); //"s->"は"(*s)."と記述してもよい。
  }
  printf("\n");
  printf("b=%f\n", s->b);
  printf("c=%lf\n", s->c);
}

void main()
{
  struct Values u;
  for(int i = 0; i < VALUES_A_LEN; i++){
    u.a[i] = i;
  }
  u.b = 3.1415;
  u.c = 1.4142;
  print_values(&u);
}

 C言語では構造体を関数の引数で渡す際、その実体でなくポインタで引き渡す理由：引数を実体で渡すと、引数をコピーする容量が増え加えてメモリを圧迫することがあり、結果としてプログラムの性能に影響を及ぼす可能性があるからです。

void print_values(struct Values s)
  //途中省略

void main()
  //途中省略
  struct Values u;
  //途中省略
  print_values(u);
  //以降省略

 リファクタリング前では、print_values()が呼び出されると最初に 変数uの値が変数sに丸ごとコピーされます。 両変数のサイズつまりstruct Valuesのサイズは、この実行環境では int(4byte)×128個 ＋ float(8byte) ＋ double(8byte) ＝ 528byte となります。つまり、ここでは528byteのコピーが行われるだけでなく、さらにuとsというまったく同じ内容の528byteの変数がメモリ上に展開されます。

 今回のケースのように528byte程度で関数の呼び出しが1回であればとくに問題となりませんが、より大きな容量で関数の呼び出しが何度も行われる場合、メモリの圧迫や処理の負荷となります。その結果としてプログラムの性能に影響を及ぼす可能性があります。

void print_values(const struct Values *s)
  //途中省略

void main()
  //途中省略
  struct Values u;
  //途中省略
  print_values(&u);
  //途中省略

 リファクタリング後では、print_values()の引数をポインタとします。そのことによってその関数が呼び出されると最初に 変数uのアドレスがポインタ変数sに設定 されます。ポインタ変数のサイズは8byteです（ポインタ変数のサイズは通常、32bitマシンであれば4byte、64bitマシンであれば8byteとなります）。

 つまり、ここではリファクタリング前のような、struct Valuesのサイズである528byteものコピーは行われませんし、同じ内容の変数がムダに重複してメモリ上に展開されることもありません。この方式だとどんなに大きなデータでも、そのポインタ変数のサイズ分（ここでは8byte）のコピーが行われるだけです。これによってコピー処理の負荷やメモリの圧迫を防ぐことができます。

 このことから、C言語では構造体を関数の引数などで渡す際にその実体でなくポインタで引き渡すことが一般的です。

 尚、リファクタリング後の関数宣言はvoid print_values(const struct Values *s)となっており、ポインタ変数の引数には const というキーワードがついています。これは「この変数はポインタで受け取るけど、この関数ではその変数の指し示す先は変更しないよ。」という意味の宣言です。constの詳細については後述します。

$ gcc -o function_pointer function_pointer.c 
$ ./function_pointer 
学生番号5番の年齢は19歳です。
Lo studente numero 8 ha 21 anni.
Studento numero 10 estas 20-jara.
$

 function_pointer.cは 関数のポインタ を使用したソースコードです。関数も変数と同様にメモリ（後述する"コード領域"）に配置されるため、アドレスを持ちポインタとして扱うことが可能です。

 関数のポインタ定義の書式は、サンプル中のvoid (*say_age)(int no, int age)で示されるように「関数の戻り値の型 (*関数へのポインタ変数名)(パラメータ群) 」とこれもまた複雑です。関数へのポインタ変数名を(*,)で括るところが特徴です。また関数のアドレスは、サンプル中のst[0].say_age = say_age_japaneseで示されるように関数名自体がそのアドレスを意味します。

 関数のポインタを利用すると関数をデータのように扱うことができるため、ソースからif文やswitch文などの分岐文が減り、コードの量が短く見通しもよい という利点があります。その半面、一見どの関数がcallされたかわかりにくくなる という欠点もあります。関数のポインタはよく利用されることがあるので、理解しておく必要があります。

$ gcc -o double_pointer double_pointer.c 
$ ./double_pointer 
a=2
$ 

 int **pp;はポインタのポインタです。ポインタのアドレスを格納します。ダブルポインタとも呼ばれます。int **pp;の書式は「ppの指し示す先、の指し示す先、はintです」と解釈します。以下にイメージを示します。

 ダブルポインタも図にするとわかりやすいです。ダブルポインタはポインタ自体を書き換えるロジックで利用されることがあるので覚えておいてください。

 実は「ポインタのポインタのポインタ…」も記述可能です。以下はその例です。

#include <stdio.h>

void main()
{
  int a = 1;
  int *p = &a; // ポインタ
  int **pp = &p; // ダブルポインタ
  int ***ppp = &pp; // トリプル？ポインタ
  int ****pppp = &ppp; // クアドラプル？ポインタ
  ****pppp = 2;
  printf("a=[%d]\n", a);
}

$ gcc -o nest_pointer nest_pointer.c 
$ ./nest_pointer 
a=2
$

 トリプルポインタ（と呼ばれるかどうかもわかっていないのですが）以降が使われることはまずありません。ここではポインタの仕組みを理解・整理するためにあえて記載しました。ダブルポインタまではその用途も交えて理解しておいてください。

#include <stdio.h>

#define A_LEN 5

void main()
{
  int a[A_LEN] = {9, 3, 4, 1, 8};
  for(int i = 0; i < A_LEN; i++){
    int w = *(a+i); //a[i] -> *(a+i) とした
    printf("a[%d]=%d\n", i, w);
  }
}

$ gcc -o array_pointer  array_pointer.c 
$ ./array_pointer
a[0]=9
a[1]=3
a[2]=4
a[3]=1
a[4]=8
$

• 配列演算子でのアクセスイメージ

int a[5] = {9, 3, 4, 1, 8}; // int a[] = {9, 3, ... と記述してもよい
printf("a[0]=%d\n", a[0]); // a[0]=9
printf("a[1]=%d\n", a[1]); // a[1]=3
printf("a[4]=%d\n", a[4]); // a[4]=8

• ポインタ演算子でのアクセスイメージ

int a[5] = {9, 3, 4, 1, 8}; // int a[] = {9, 3, ... と記述してもよい
printf("a[0]=%d\n", *a); // a[0]=9
printf("a[1]=%d\n", *(a+1)); // a[1]=3
printf("a[4]=%d\n", *(a+4)); // a[4]=8

 C/C++言語でたとえばint a[3];と記述すると「int型の要素数5を持つ配列を定義する」となります。これは厳密には「int型(4byte)の領域をメモリ上に連続して3つ確保するだけ」です。

 以下にそのイメージを示します。

int a[3] = {9, 3, 4};

 上の図はint a[3]によってその変数aがアドレス0x30000から割り当てられたとした場合のメモリイメージです。配列名のaはその先頭のアドレスを意味します。そのため*aとするとそれはaが指し示す先となりここでは9となります。

 *(a+1)については、次のように式を要素に分解して解釈します。

• a：先頭のアドレス（例では0x30000）です。
• a+1：先頭のアドレスからintサイズ1つ分先のアドレス（例では0x30004）です。
• *(a+1)：上のa+1の指し示す先（例では3）です。同じ仕組みで*(a+2)は4となります。
  
  

 a+1のようにアドレス（ポインタ）の値を変えることをポインタ演算といいます。このように配列はポインタ演算を用いてアクセスすることが可能です。尚、a+1の1は1byteではなくその型の大きさ（ここではintの4byte）を意味します。ここも初心者はよく間違えるので注意してください。

• 配列とポインタの考え方

 C/C++言語ではソースコード上では配列での記述が可能ですが、ビルドした結果のプログラムには配列という概念はなくなります。つまりa[4]はビルド後には*(a+4)に置き換わる、と考えてよいでしょう。

 それでもプログラマとしては、配列へのアクセスは*(a+4)といったポインタ演算子より、a[4]といった配列演算子の書式の方がわかりやすいため、そのように書くことが奨励されているケースが多いです。しかし*(a+4)と書くケースもあります。

 ここでは 配列は結局のところポインタとして扱われる と理解しておくことが重要です。

#include <stdio.h>

// 機能：要素数がarray_numのintの配列を標準出力する
void print_array(const int array[], int array_num)
{ // 上の int array[] は int *array でもよい。
  for(int i = 0; i < array_num; i++){
    // 以下の array[i] は *(array+i) でもよい
    printf("array[%d]=%d\n", i, array[i]);
  }
}

void main()
{
  int a[5] = {9, 3, 4, 1, 8};
  print_array(a, 5);
}

$ gcc -o array_parameter array_parameter.c
$ ./array_parameter
array[0]=9
array[1]=3
array[2]=4
array[3]=1
array[4]=8
$ 

  C/C++では配列要素の全てを一つのパラメータで渡すことができません。 そのため配列要素のすべてをアクセスするには配列の先頭アドレス（ポインタ）を渡す必要があります。変数名aが配列の先頭アドレスを意味するので、ここではprint_array(a, 5);として呼び出します。

 受け側の関数のアーギュメントはint array[]と定義されていますが、これはint *arrayと記述しても構いません。いずれもintへのポインタです。このポインタを介して配列全体にアクセスします。尚、この受け側の関数のアーギュメントはint array[5]との記述も可能ですが、その5は意味がありません。分かりにくいですがいずれもポインタint *arrayとみなされます。

 先ほど「C/C++は配列要素のすべてを1つのパラメータで渡すことができない」と記述しましたが、実は構造体の中にある配列に関してはその構造体の実体（非ポインタ）をパラメータで渡すことによって、配列全体も渡すことができます。設問2.1.4のリファクタリング前のstruct_parameter.cがその例です。ただしその解答で説明しているとおり、一般的には構造体の実体渡し（非ポインタ渡し）は奨励されていません。

#include <stdio.h>

char *mystrcpy_array(char *dest, const char *src)
{
  for(int i = 0;;i++){
    dest[i] = src[i];
    if(src[i] == '\0'){
      break;
    }
  }
  return dest;
}

char *mystrcpy_pointer(char *dest, const char *src)
{
  char *tmp = dest;
  while ((*dest++ = *src++) != '\0')
    /* nothing */;
  return tmp;
}

void main()
{
  {
    char a[128];
    char b[128] = "abcd";
    char *p;
    p = mystrcpy_array(a,b);
    printf("mystrcpy_array():p=%s\n", p);
  }
  {
    char a[128];
    char b[128] = "abcd";
    char *p;
    p = mystrcpy_pointer(a,b);
    printf("mystrcpy_pointer():p=%s\n", p);
  }
}

$ gcc -o mystrcpy mystrcpy.c
$ ./mystrcpy
mystrcpy_array():p=abcd
mystrcpy_pointer():p=abcd
$ 

 ここでは解答として、配列演算子を用いたmystrcpy_array()と、ポインタ演算子を用いたmystrcpy_pointer()の2つのバージョンを記述しました。後者はLinuxの標準関数strcpy()で実際に記述されているコードです。短くてシンプルです。17行目のwhile ((*dest++ = *src++) != '\0')の意味が分かりますか？

• C言語の文字列とは

  C言語には文字列型がありません。なんということでしょう。文字列型といった極めて基本的な型を持たないプログラミング言語がいまだにWindowsやLinuxといったOSの開発に使用されているのです！

 C言語では文字型charの配列を文字列 とみなします。ただし、他の型の配列と違って'\0'を配列の末端とみなします。

char x[128] = "abcd";

 具体的には"abcd"といった文字列リテラルを記述すると、上の図のようにその後ろに'\0'（NULLストッパー）が自動で付加されます。そしてstrcpyなどといった文字列標準関数はそのNULLストッパーがあることを前提として、つまりそのNULLの1つ手前までのcharの配列を「文字列」とみなしてロジックが記述されています。これがcharの配列つまり「文字列」の特徴です。それ以外はintやその他の型の配列とまったく同様です。

 このことから文字列もポインタ演算子や配列演算子を用いてアクセスします。C言語の教則本によってはこの配列やポインタの説明をしないままに文字列を説明をしているものを見かけます。これもポインタの理解の妨げになっている理由の1つです。

#ifndef _MYSTRCAT_
#define _MYSTRCAT_

extern char *mystrcat(char *dest, const char *src);
//mystrcmp()以降は省略

#endif // _MYSTRCAT_

#include <stdio.h>

char *mystrcat(char *dest, const char *src)
{
  // get dest length (strlen)
  int dest_len;
  for(int i = 0;;i++){
    if(dest[i] == '\0'){
      dest_len = i;
      break;
    }
  }

  // copy dest to src (strcpy)
  for(int i = 0;;i++){
    dest[i+dest_len] = src[i];
    if(src[i] == '\0'){
      break;
    }
  }
  return dest;
}

//mystrcmp()以降は省略

#include <stdio.h>
#include "mystring.h"

void main()
{
  {
    char a[128] = "abcd";
    char b[128] = "efg";
    char *p;
    p = mystrcat(a,b);
    printf("mystrcat():p=%s\n", p);
  }
  
  //mystrcmp()以降は省略
}

$ gcc -o mystring_test mystring.c mystring_test.c
$ ./mystring_test 
mystrcat():p=abcdefg
$ 

 mystring.hの1,2,7行目のプリプロセッサ文は、多重インクルードされることを防止するための定石です。その意味を理解し覚えておいてください。

#include <stdio.h>

int main(int argc, char *argv[])
{
  printf("program name=%s\n", argv[0]);
  for(int i = 1; i < argc; i++){
    printf("arg%d=%s\n", i, argv[i]);
  }
  return 0;
}

 C/C++プログラムを起動した際、main()の引数であるargcにはコマンド名も含めた引数の個数が設定され、argvにはコマンド名と引数群がポインタ配列として設定されます。

$ ./main_arg abc 1285 def

 3行目のchar *argv[]はcharのポインタ配列です。書式の読み方としては「argは[]（配列）であり、その配列要素の*（指し示す先）はcharである」と解釈します。

 5,7行目のargv[0]やargv[i]はそれぞれがポインタ配列の1要素です。よってそれ自体がポインタです。そこには、プログラム名文字列のアドレス、引数文字列のアドレス、が格納されています。argcはポインタ配列の要素数です。

 ポインタ配列こそ図にしないとわかりにくいものです。よく出てくるのでしっかり理解しておいてください。

• コード領域（静的領域、プログラム領域）：nval, sval, counter, "abcde", "p=%s\n"
    グローバル変数、static変数、文字列リテラルは、プログラム起動時にコード領域に配置 され、プログラムが終わるまでその領域は保証されます。「静的領域」の名前の由来です。変数定義時に明示的に初期化しなければ0x00が設定されます。また、プログラムコード（ロジック）も同様にコード領域に確保されます。「プログラム領域」の名前の由来です。
  
  

• スタック領域：dest, tmp, mp, str, p
    ローカル変数は、その変数定義時にスタック領域に積まれ、その変数を定義したブロック{～}が終了した時点でスタック領域から外されます。 この動作は"スタック"（積み上げる）のイメージの通りです。尚、変数定義時に明示的に初期化しなければその値は不定です。
  
  

• ヒープ領域：malloc()で確保された領域
    malloc関数（C++ではnew)にてサイズ指定されたエリアはヒープ領域に確保されます。 そして明示的にfree関数（C++ではdelete）が実行されるとその領域が解放されます。尚、malloc関数については領域確保時に明示的に初期化しなければその値は不定です。C++のnew演算子については後述します。
  
  

 コード領域は、プログラム全体を通してサイズや個数が変わらない静的なデータ を配置するのに向いています。要はグローバル変数、static変数のことですが、近年はスコープの概念からこれらはあまり利用されません。ただし、組込みソフトウェアではよく使用されます。

 スタック領域は、ブロック{～}が終了した時点で自動解放されるため、一時変数として利用されます。一時変数とはいえ、引数を使って下位関数に渡していくことができるので利用頻度は非常に広いです。

 ヒープ領域は、プログラム全体を通してサイズや個数が変わる動的なデータ を配置するのに向いています。たとえば、通常にint a[32];と定義した場合、32個のintのデータは管理できますが、32個を越えるととたんに管理できなくなります。コード領域やスタック領域の配列のサイズを定義後に変更することはできないためです。ヒープ領域をうまく利用すればこういった領域のサイズを変更できます。また、使用したい領域の生成、消滅のタイミングをコントロールできることも利点です。このようにメモリをより自由かつ動的に利用できます。

 ただし、ヒープ領域については注意すべき項目もあります。malloc（new）はそれがcallされるたびに新たな領域が確保されます。したがって適切なタイミングでfree（delete）をしてあげないとヒープに領域が溜まり続けメモリリークとなってしまいます。メモリリークは、Linuxではデーモン、Windowsではサービスといった「常時動き続けるプログラム」で発生するとより深刻です。そのプログラムがOS全体のメモリを食いつくしてしまう可能性があるためです。メモリリークの検知と対策については後述します。

#include <iostream>

// 機能：a と b を足して c に設定する
void add(int a, int b, int &c) // int &c; はintの参照型
{
  c = a + b;
}

int main()
{
  int x = 2;
  int y = 3;
  int z = 0;
  add(x, y, z);
  std::cout << "z=" << z << std::endl; // "z=5"を期待!
  return 0;
}

$ g++ -o call_by_reference call_by_reference.cpp 
$ ./call_by_reference 
z=5
$ 

 4行目のint &c;はintの参照型です。参照型はC++で取り入れられた新しい型です。14行目で&zなくzと記述し、6行目で cを更新するとzの値が更新されます。

 ポインタを使うと各変数を使用する際、変数の頭に&や*を付ける必要がありましたが、参照型ではそれがなくなります。よって、&や*といったシンボルに悩むことなくスムーズにコードを読み書きできます。このことからC++言語ではポインタに代わって参照型が多用されています。

#include <iostream>
#include <vector>

// 機能：source配列をdest配列にコピーする
void myvectorcpy(std::vector<int> &dest, const std::vector<int> &source)
{
  for(int i = 0; i < source.size(); i++){
    dest.push_back(source[i]); // destの末尾に追加する
  }
  // もしくは以下でもよい
  //std::copy(source.begin(), source.end(), std::back_inserter(dest));
}

int main()
{
  std::vector<int> a;
  std::vector<int> b = {9, 3, 4, 1, 8};
  myvectorcpy(a, b);
  for(int i = 0; i < a.size(); i++){
    std::cout << "a[" << i << "]=" << a[i] <<std::endl;
  }
  return 0;
}

$ g++ -o vector_cpy vector_cpy.cpp
$ ./vector_cpy 
a[0]=9
a[1]=3
a[2]=4
a[3]=1
a[4]=8
$ 

 std::vector<>はSTL(Standard Template Library)のコンテナクラスの一種です。参照型として受け取った関数にて8行目のdest.push_back(source[i]);が実行されると、destつまりaの末尾にbのi番目の値がプッシュされます。

 また、C言語の配列は固定長ですがstd::vector<>は可変長の配列です。よって16行目のstd::vector<int> a;のようにサイズを指定していなくとも、push_back()などのメンバ関数によって領域を増やしつつコピーをすることが可能です。C++でも配列の使用は可能ですが、とくに制約がなければ配列の代わりにstd::vector<>を使用すべきです。

 5行目のvoid myvectorcpy(std::vector<int> &dest, const std::vector<int> &source)のアーギュメントに注目してください。sourceにはconstキーワードがついています。C言語と同様にこれは「参照型で受け取るけど、この関数ではその変数の指し示す先は変更しないよ。」という意味の宣言です。C++ではクラスを関数に渡す場合、通常は参照型で渡します。参照型で渡すことによってその関数での変更が可能となりますが、変更しない変数にはあえてconstをつけることによって、その関数の使用者に機能を明示できます。これもC/C++での一般的なルールとなっています。

#include <iostream>
#include <string>

// 機能：source文字列をdest文字列にコピーする
void mystringcpy(std::string &dest, const std::string &source)
{
  dest = source;
}

int main()
{
  std::string a;
  std::string b = "abcd";
  mystringcpy(a, b);
  std::cout << "a=" << a <<std::endl;
  return 0;
}

$ g++ -o string_cpy string_cpy.cpp 
$ ./string_cpy 
a=abcd
$ 

 std::stringはSTL(Standard Template Library)の文字列クラスです。文字列型が存在しなかったC言語に対してC++は文字列型が存在する のです。他の言語の利用者から見れば信じがたいことでしょうが、これは各段の進化なのです！

 またstd::stringは配列でなく1つの型なので、7行目のdest = source;のように代入式も他のint型のように簡単に記述できます。さらに先述の"std::vector<>"と同様に代入先のサイズも気にする必要はありません。とにかく各段の進化なのです！

#include <iostream>
#include <string>

class Person
{
private:
  std::string name;
  int age;

public:
  Person(const std::string & in_name, int in_age)
  {
    name = in_name;
    age = in_age;
  }
  /* 上のコンストラクタは以下の書き方が奨励されます。
  Person(const std::string & in_name, int in_age):
    name(in_name), age(in_age){} // 初期化リストで初期化
  */
  
  void print() const
  {
    std::cout << "name=" << name << std::endl;
    std::cout << "age=" << age << std::endl;
  }
};

int main()
{
  { // make Person instance at stack.
    Person ps("john", 20);
    ps.print();
  }
  { // make Person instance at heap.
    Person *ps = new Person("paul", 19);
    ps->print();
    delete ps;
  }
  return 0;
}

$ g++ -o new_delete new_delete.cpp 
$ ./new_delete 
name=john
age=20
name=paul
age=19
$ 

 31行目のPerson ps("john", 20);の記述によって、Person型のpsという名のローカル変数をスタックに配置します。psはポインタでなく実体型なので32行目のメンバ関数の呼び出しはドット演算子.を介したps.print();となります。

 35行目のPerson *ps = new Person("paul", 19);ではnewの記述によってPerson型のサイズの領域がヒープに展開され、そのアドレスがpsというポインタに設定されます。ps自体はスタック上に存在するローカル変数であることに注意してください。尚、psはポインタなので36行目のメンバ関数の呼び出しはアロー演算子->を介したps->print();となります。

 続いて37行目のdelete ps;にて、ヒープに確保した領域をポインタps経由で解放しています。今回のプログラムではそのままmain関数が終了し全メモリが解放されるので、deleteせずとも大きな影響はありませんが、通常はヒープに確保した領域は不要になった時点で必ず解放する必要があります。メモリリークを回避するためです。

 C++言語での開発において、このようにクラスをインスタンス化する際に、 スタックに展開すべきか？ヒープに展開すべきか？ の判断を迷うケースがあります。これについてはたとえば「オブジェクトをほんの数ステップだけ使用するようなケースであれば、わざわざヒープに配置する必要はない」という考え方もあります。また「サイズが巨大なオブジェクトは'スタックオーバーフロー'を起こす可能性があるのでヒープに配置すべき」という考え方もあります。

 この判断基準は、プログラムの動作環境（メモリ容量・CPU性能）に依存するはずなので「動作環境に関する制約がなければどちらでも構わない」との考えでよいです。

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int g_a;
void func1(){
  //__func__は現在の関数名
  printf(">start %s()\n", __func__);
  //解説：local変数は初期化しないと不定値
  //int a;
  int a = 0;
  printf("g_a=%d, a=%d\n", g_a, a);
  //期待する出力："g_a=0, a=0"
}
void func2(){
  printf(">start %s()\n", __func__);
  char a[128];
  //解説：文字列を配列で1charづつ定義した場合、
  //      Nullストッパは自動ではつかない！自力でつけること。
  //char b[] = {'k','u','m','a', 'm', 'o', 't', 'o'};
  char b[] = {'k','u','m','a', 'm', 'o', 't', 'o', '\0'};
  strcpy(a, b);
  printf("a=%s\n", a);
  //期待する出力："a=Kumamoto"
}
void func3(){
  printf(">start %s()\n", __func__);
  //解説：Nullストッパ分のエリアが不足している。
  //char a[8];
  char a[9];
  char *b = "Kumamoto";
  strcpy(a, b);
  printf("a=%s\n", a);
  //期待する出力："a=Kumamoto"
}
void func4(){
  printf(">start %s()\n", __func__);
  //解説：ポインタのエリアは確保されているが
  //      その指し示す先のエリアが確保されていない。
  //char *a;
  char a[9];
  char *b = "Kumamoto";
  strcpy(a, b);
  printf("a=%s\n", a);
  //期待する出力："a=Kumamoto"
}
void func5(){
  printf(">start %s()\n", __func__);
  int *a = 0x00;
  //解説：Nullアドレス参照(いわゆる"ヌルポ")。
  int b;
  a = &b;
  *a = 0;
  printf("a=%d\n", *a);
  //期待する出力："a=0"
}
void func6(){
  printf(">start %s()\n", __func__);
  int *a;
  //解説：不定アドレスの参照
  //*a = 2;
  int b;
  a = &b;
  *a = 2;
  printf("*a=%d\n", *a);
  //期待する出力："a=2"
}
void func7(){
  printf(">start %s()\n", __func__);
  int a[] = {3, 9, 7, 4};
  //解説：*演算子と+演算子は*演算子の優先度が高い。
  //printf("a[2]=%d\n", *a+2);
  printf("a[2]=%d\n", *(a+2));
  //期待する出力："a[2]=7"
}
void func8(){
  printf(">start %s()\n", __func__);
  int a[4];
  int b[] = {3, 9, 7, 4};
  //解説：sizeof(配列名)は配列要素数でなく配列のbyte数
  //memcpy(a, b, sizeof(b) * sizeof(int));
  memcpy(a, b, sizeof(b));
  for(int i = 0; i < 4; i++){
    printf("a[%i]=%d ", i, a[i]);
  }
  printf("\n");
  //期待する出力："a[0]=3 a[1]=9 a[2]=7 a[3]=4 "
}
void func9(){
  printf(">start %s()\n", __func__);
  //解説：mallocで確保された値は初期化されない。
  //int *a = (int*)malloc(sizeof(int) * 4);
  int *a = (int*)calloc(1, sizeof(int) * 4); //0x00で初期化
  a[1] = 9; a[3] = 4;
  for(int i = 0; i < 4; i++){
    printf("a[%i]=%d ", i, a[i]);
  }
  printf("\n");
  free(a);
  //期待する出力："a[0]=0 a[1]=9 a[2]=0 a[3]=4 "
}
void func10(){
  printf(">start %s()\n", __func__);
  char *a;
  a = (char*)malloc(128);
  strcpy(a, "Kumamoto");
  printf("a=%s\n", a);
  //解説：free()漏れ。メモリリークしていた。
  free(a);
  a = (char*)malloc(128);
  strcpy(a, "Fukuoka");
  printf("a=%s\n", a);
  free(a);
  //期待する出力："a=Kumamoto"
  //　　　　　　　"a=Fukuoka"
}
void func11(){
  printf(">start %s()\n", __func__);
  char *a;
  a = (char*)malloc(128);
  strcpy(a, "Kumamoto");
  printf("a=%s\n", a);
  free(a);
  char *b = a;
  a = (char*)malloc(128);
  strcpy(a, "Fukuoka");
  printf("a=%s\n", a);
  free(a);
  //解説：aとbは同じため結果として2重free()していた。
  //free(b);
  //期待する出力："a=Kumamoto"
  //　　　　　　　"a=Fukuoka"
}
int main(){
  func1();
  func2();
  func3();
  func4();
  func5();
  func6();
  func7();
  func8();
  func9();
  func10();
  func11();
  return 0;
}

$ gcc -o memory_error memory_error.c 
$ ./memory_error 
>start func1()
g_a=0, a=0
>start func2()
a=kumamoto
>start func3()
a=Kumamoto
>start func4()
a=Kumamoto
>start func5()
a=0
>start func6()
*a=2
>start func7()
a[2]=7
>start func8()
a[0]=3 a[1]=9 a[2]=7 a[3]=4 
>start func9()
a[0]=0 a[1]=9 a[2]=0 a[3]=4 
>start func10()
a=Kumamoto
a=Fukuoka
>start func11()
a=Kumamoto
a=Fukuoka