はい、承知いたしました。C言語のreturn文について、約5000語の詳細な解説記事を作成します。

---

C言語 return文の正しい使い方と具体的なコード例：関数からの脱出と値の返却をマスターする

はじめに

C言語における関数は、特定の処理をひとまとまりにし、再利用可能にするための基本的な構成要素です。関数は、与えられた入力（引数）に基づいて処理を行い、その結果を呼び出し元に返すことがあります。この「結果を返す」という動作や、「関数の実行を終了する」という制御は、return文によって実現されます。

return文は一見シンプルですが、その使い方には様々な側面があり、正しく理解しないと意図しない挙動やバグの原因となり得ます。特に、戻り値の型、void関数の扱い、複数の値を返す方法、そしてポインタや構造体を扱う場合の注意点などは、C言語プログラミングにおいて非常に重要です。

この記事では、C言語のreturn文について、その基本的な役割から始まり、多岐にわたる具体的なコード例を通じて、正しい使い方と避けるべき落とし穴を詳細に解説します。この記事を読むことで、あなたはC言語における関数の戻り値とreturn文の動作原理を深く理解し、より堅牢で効率的なプログラムを書けるようになるでしょう。

C言語における関数とは何か

return文を理解するためには、まずC言語における関数について基本的な理解が必要です。

関数は、特定のタスクを実行するために設計された、コードの独立したブロックです。関数を使用することで、プログラムを小さな、管理しやすい部品に分割できます。これにより、コードの可読性が向上し、同じコードを何度も書く必要がなくなり（再利用性）、プログラムの保守やデバッグが容易になります。

すべてのC言語プログラムには、実行開始点となる特別な関数、main関数が一つだけ存在します。プログラムの実行は、通常、main関数の先頭から開始されます。

関数の基本的な形は以下のようになります。

c
戻り値の型 関数名(引数のリスト) {
// 関数の本体（処理コード）
// ...
// 必要に応じて return 文
}

• 戻り値の型: 関数が処理を終えた後、呼び出し元に返す値のデータの型を指定します。何も値を返さない関数の場合は、voidを指定します。
• 関数名: 関数を識別するための名前です。命名規則に従って付けます。
• 引数のリスト: 関数が処理を行うために外部から受け取るデータ（引数）のリストです。各引数は「型 引数名」の形式で記述し、複数ある場合はカンマで区切ります。引数がない場合は、voidまたは何も記述しません（古いスタイルでは何も書かないこともありますが、引数がないことを明示するためにvoidと書くのが一般的です）。
• 関数の本体: 実際にその関数が行う処理を記述する部分です。波括弧 {} で囲まれたブロックです。

関数は、他の関数から「呼び出し」によって実行されます。関数が呼び出されると、呼び出し元での実行がいったん中断され、呼び出された関数の本体の先頭から実行が開始されます。呼び出された関数が処理を終えると、実行は呼び出し元に戻り、中断された箇所から再開されます。

return文の基本

return文は、C言語において以下の二つの主要な役割を果たします。

1. 関数の実行を終了する: return文が実行されると、その関数内のそれ以降のコードは実行されずに、直ちに関数の実行が終了します。
2. 呼び出し元に関数の実行結果（戻り値）を返す: return文に式を指定した場合、その式の評価結果が呼び出し元に渡されます。

return文には、大きく分けて二つの形式があります。

1. return;: 値を返さない場合（void型関数）に使用します。関数の実行を終了する目的でのみ使用されます。
2. return expression;: 指定したexpression（式）の評価結果を戻り値として返す場合に使用します。この形式は、void型以外の戻り値を持つ関数で使用されます。

戻り値の型とreturn文

関数が特定の戻り値の型（例: int, float, char*, struct MyStruct など）で宣言されている場合、その関数内のreturn文は、その型と互換性のある値を返す必要があります。

例：
“`c
int add(int a, int b) {
int sum = a + b;
return sum; // int 型の値を返す
}

double calculate_area(double radius) {
double area = 3.14159 * radius * radius;
return area; // double 型の値を返す
}
“`

関数がvoid型で宣言されている場合、その関数は値を返しません。このような関数では、return; 形式を使用するか、または関数本体の末尾まで到達して暗黙的に終了します。void関数で return expression; の形式を使用すると、コンパイルエラーになります。

例：
“`c
void print_message(const char* msg) {
printf(“%s\n”, msg);
return; // void 関数なので値を返さない。処理をここで終了。
// この下の行は return 文の実行後は到達しない
// printf(“This line will not be printed.\n”);
}

void greet(const char* name) {
printf(“Hello, %s!\n”, name);
// 関数の末尾に到達した場合、暗黙的に return; と同じように終了する
}
“`

重要: 戻り値を持つ関数（void型でない関数）では、関数のすべての可能な実行パスにおいて、return expression; が実行される必要があります。もし、ある条件分岐などの結果、return文に到達しない可能性がある場合、それは未定義動作を引き起こす可能性があり、通常はコンパイラが警告を発します。

return文の具体的な使い方とコード例

ここからは、さまざまな状況におけるreturn文の具体的な使い方をコード例と共に詳しく見ていきます。

1. 基本的な戻り値を持つ関数

最も一般的なケースは、数値や文字などの基本的なデータ型を戻り値として返す関数です。

例1: 2つの整数の加算

“`c

include

// 2つの整数を受け取り、その合計を返す関数
int add(int a, int b) {
int result = a + b;
return result; // 合計値を戻り値として返す
}

int main() {
int num1 = 10;
int num2 = 20;
int sum;

// add 関数を呼び出し、戻り値を sum 変数に格納
sum = add(num1, num2);

printf("The sum of %d and %d is %d\n", num1, num2, sum); // 出力: The sum of 10 and 20 is 30

return 0; // main 関数も int 型なので戻り値を返す

}
“`

解説:

• add関数は int 型の戻り値を持ちます。
• 関数内で計算された result（int型）の値が return result; によって呼び出し元に返されます。
• main関数内の sum = add(num1, num2); の行では、add関数の呼び出しが実行され、add関数が返した値（30）が変数 sum に代入されます。
• main関数も int 型の戻り値を持つため、最後に return 0; で終了します。慣習として、main関数が0を返すとプログラムは正常終了とみなされます。

例2: 文字が大文字かどうか判定

“`c

include

include // isupper関数を使うために必要

// 文字を受け取り、それが大文字であれば1（真）、そうでなければ0（偽）を返す関数
int is_uppercase(char c) {
if (c >= ‘A’ && c <= ‘Z’) {
return 1; // 大文字であれば 1 を返す
} else {
return 0; // それ以外であれば 0 を返す
}
}

// 標準ライブラリの isupper 関数を使った例 (通常はこちらを使う)
int is_uppercase_std(char c) {
return isupper(c) ? 1 : 0; // isupper が真（非0）なら 1、偽（0）なら 0 を返す
}

int main() {
char ch1 = ‘A’;
char ch2 = ‘a’;

if (is_uppercase(ch1)) { // is_uppercase(ch1) の呼び出し結果（1）が評価される
    printf("'%c' is an uppercase letter.\n", ch1); // 出力される
}

if (is_uppercase(ch2)) { // is_uppercase(ch2) の呼び出し結果（0）が評価される
    // 何も出力されない
} else {
    printf("'%c' is not an uppercase letter.\n", ch2); // 出力される
}

printf("Using std function: '%c' is uppercase? %d\n", ch1, is_uppercase_std(ch1)); // 出力: Using std function: 'A' is uppercase? 1
printf("Using std function: '%c' is uppercase? %d\n", ch2, is_uppercase_std(ch2)); // 出力: Using std function: 'a' is uppercase? 0

return 0;

}
“`

解説:

• is_uppercase関数は int 型の戻り値を持ち、真偽値を慣習的な方法（非0を真、0を偽）で返します。
• 条件分岐 if (c >= 'A' && c <= 'Z') の結果に応じて、return 1; または return 0; のいずれかが実行されます。
• どちらの return 文が実行されても、関数は直ちに終了し、対応する値（1または0）が呼び出し元に返されます。
• main関数では、if (is_uppercase(ch1)) のように、is_uppercase関数の戻り値が直接条件式として使われています。C言語では、0以外の値は真と評価されるため、この書き方が可能です。

2. void型関数のreturn文

void型の関数は値を返しません。しかし、return; 文を使用することで、関数の途中であっても実行を終了させることができます。これは、特定の条件が満たされた場合に、それ以降の処理をスキップしたい場合などに便利です。

例3: 特定の条件で処理を中断

“`c

include

// 数値を受け取り、それが負数であればエラーメッセージを表示して終了する関数
void process_positive_number(int num) {
if (num < 0) {
fprintf(stderr, “Error: Input number must be positive.\n”);
return; // 負数の場合はここで関数を終了
// この return 文以降のコードは実行されない
}

// ここから先は num が 0 以上の場合のみ実行される
printf("Processing positive number: %d\n", num);
// その他の処理...

}

int main() {
process_positive_number(10); // 出力: Processing positive number: 10
process_positive_number(-5); // 出力: Error: Input number must be positive.

return 0;

}
“`

解説:

• process_positive_number関数は void 型なので、値を返しません。
• 引数 num が負数であるかどうかがチェックされます。
• もし num < 0 が真の場合、エラーメッセージを表示した後、return; が実行されます。これにより、関数はこの時点で終了し、"Processing positive number..." というメッセージは表示されません。
• もし num < 0 が偽の場合、if ブロック内のコードはスキップされ、その後の printf 文が実行されます。関数本体の最後まで到達すると、暗黙的に終了します（return; と同じ効果）。

3. ポインタを返す関数

関数は、メモリ上の特定の場所を指し示すポインタを戻り値として返すこともできます。これは、動的に確保されたメモリ領域や、グローバル変数/静的変数のアドレスを返す場合などに利用されます。ただし、関数の内部で宣言されたローカル変数のアドレスを返してはいけません。

例4: 動的に確保した整数へのポインタを返す

“`c

include

include // malloc, free 関数を使うために必要

// 動的に整数を確保し、初期値を設定してそのポインタを返す関数
int create_dynamic_int(int initial_value) {
// sizeof(int) バイトのメモリをヒープ領域に確保
int ptr = (int*)malloc(sizeof(int));

// malloc が失敗した場合 (メモリ不足など) は NULL を返す可能性がある
if (ptr == NULL) {
    perror("Failed to allocate memory"); // エラーメッセージを表示
    return NULL; // 確保失敗時は NULL を返す
}

// 確保したメモリ領域に初期値を書き込む
*ptr = initial_value;

return ptr; // 確保したメモリ領域の先頭アドレス (ポインタ) を返す

}

int main() {
int* my_int_ptr;

// create_dynamic_int 関数を呼び出し、動的に確保されたメモリへのポインタを受け取る
my_int_ptr = create_dynamic_int(100);

if (my_int_ptr != NULL) {
    printf("Dynamically allocated int value: %d\n", *my_int_ptr); // 出力: Dynamically allocated int value: 100

    // 使用が終わったらメモリを解放する責任がある
    free(my_int_ptr);
    my_int_ptr = NULL; // 解放済みのポインタを使わないように NULL を代入する
} else {
    printf("Memory allocation failed.\n");
}

return 0;

}
“`

解説:

• create_dynamic_int関数は int* 型の戻り値を持ちます。これは「int型へのポインタ」を返すことを意味します。
• malloc関数を使ってヒープ領域にメモリを確保します。ヒープ領域に確保されたメモリは、free関数で明示的に解放されるまで有効です。
• mallocが成功した場合、確保されたメモリブロックの先頭アドレス（ポインタ）が返されます。このポインタを return ptr; で呼び出し元に返しています。
• mallocが失敗した場合（戻り値がNULL）、エラーメッセージを表示し、NULLポインタを返しています。呼び出し元は返されたポインタがNULLでないか確認する必要があります。
• main関数では、受け取ったポインタ my_int_ptr を使って、確保されたメモリ上の値にアクセス（*my_int_ptr）しています。
• 動的に確保したメモリは、使用後に必ず free 関数で解放する必要があります。これは呼び出し元の責任となります。

絶対に行ってはいけないこと: ローカル変数のアドレスを返す

“`c

include

// *** これは絶対にやってはいけない間違ったコード例です ***
int create_local_int_BAD() {
int local_value = 123;
printf(“Inside function: address of local_value is %p\n”, (void)&local_value);
return &local_value; // ローカル変数のアドレスを返している！
}

int main() {
int* dangling_ptr;

dangling_ptr = create_local_int_BAD();

// WARNING: このポインタ dangling_ptr は無効です！
// 関数 create_local_int_BAD が終了した時点で、
// そのスタックフレーム上の local_value は無効になり、
// そのメモリ領域は他の用途で上書きされる可能性があります。

printf("Outside function: returned address is %p\n", (void*)dangling_ptr);
// WARNING: 無効なポインタを逆参照すると未定義動作を引き起こします！
// printf("Outside function: value is %d\n", *dangling_ptr); // *** 危険なコード！ ***

return 0;

}
“`

解説:

• local_valueはcreate_local_int_BAD関数のローカル変数です。ローカル変数は、その変数が宣言されているブロック（この場合は関数本体）の実行中のみ存在します。これらの変数は通常、スタック上に割り当てられます。
• 関数が終了すると、その関数のためにスタック上に確保されていた領域（スタックフレームと呼ばれます）は解放され、その領域にあったローカル変数も無効になります。
• return &local_value; は、この無効になったメモリ領域のアドレスを返しています。
• main関数で受け取ったポインタ dangling_ptr は、解放済みのメモリを指しています。このようなポインタをダングリングポインタ (dangling pointer) と呼びます。
• ダングリングポインタを逆参照してその値を読み書きしようとすると、未定義動作 (undefined behavior) を引き起こします。これは、プログラムがクラッシュしたり、予期しない値を読んだり、他の重要なデータが上書きされたりする可能性があることを意味します。コンパイラや実行環境によって挙動は異なりますが、いずれにせよ信頼性のないプログラムになります。

この危険を避けるためには、ポインタを返す場合は、動的に確保されたメモリ（mallocなどで確保し、freeで解放する）か、関数の外で有効な変数（グローバル変数や静的変数など）のアドレスを返す必要があります。

4. 構造体や共用体を返す関数

C99規格以降、関数は構造体や共用体を値渡しで返すことができるようになりました。関数内で作成した構造体のコピーを呼び出し元に渡すことができます。

例5: 座標構造体を返す

“`c

include

// 2次元座標を表す構造体
typedef struct {
int x;
int y;
} Point;

// 2つの整数を受け取り、それらを座標とする Point 構造体を作成して返す関数
Point create_point(int x_val, int y_val) {
Point p; // ローカル変数として構造体を宣言
p.x = x_val;
p.y = y_val;
return p; // 構造体 p のコピーを戻り値として返す
}

// Point 構造体の内容を表示する関数 (void型)
void print_point(Point p) {
printf(“Point: (%d, %d)\n”, p.x, p.y);
}

int main() {
// create_point 関数を呼び出し、Point 構造体のコピーを受け取る
Point origin = create_point(0, 0);
Point p1 = create_point(10, 20);

print_point(origin); // 出力: Point: (0, 0)
print_point(p1);     // 出力: Point: (10, 20)

return 0;

}
“`

解説:

• Point構造体が定義されています。
• create_point関数は Point 型の戻り値を持ちます。
• 関数内部でローカル変数 p として Point 構造体を作成し、そのメンバーに値を設定しています。
• return p; は、ローカル変数 p の値全体（つまり、構造体の全メンバーの値）をコピーして呼び出し元に返します。create_point関数が終了した後も、返された構造体のコピーは呼び出し元で有効です。
• main関数では、Point origin = create_point(0, 0); のように、返された構造体のコピーが新しい Point 型変数 origin に代入されています。

注意点:

• 構造体や共用体を値渡しで返すと、その内容全体がコピーされます。構造体が大きい場合（メンバーの数が多い、大きな配列を含んでいるなど）、このコピー処理には時間がかかったり、多くのメモリ（スタック領域など）を消費したりする可能性があります。
• 大きな構造体を効率的に扱う必要がある場合は、構造体そのものを返すのではなく、構造体へのポインタを返すか、引数としてポインタを受け取り、そのポインタが指す先に結果を書き込むという方法を検討するのが一般的です。

5. 配列を返す関数（直接は不可）と代替手段

C言語では、関数が配列そのものを戻り値として直接返すことはできません。関数の戻り値として指定できるのは、単一の値（スカラ型、ポインタ、構造体、共用体）のみです。

しかし、関数から配列のようなデータ構造を「返す」ための代替手段がいくつか存在します。

代替手段1: 配列へのポインタを返す

動的に確保した配列や、静的に確保された（グローバルまたは静的）配列へのポインタを返す方法です。ローカル配列のアドレスを返してはいけません。

“`c

include

include // malloc, free を使用

// 動的に確保した int 型の配列へのポインタを返す関数
// size: 確保する配列の要素数
int create_int_array(int size) {
// size * sizeof(int) バイトのメモリを動的に確保
int arr = (int*)malloc(size * sizeof(int));

if (arr == NULL) {
    perror("Failed to allocate memory for array");
    return NULL; // 失敗時は NULL を返す
}

// 配列に初期値を設定する例 (ここではインデックスを値として設定)
for (int i = 0; i < size; i++) {
    arr[i] = i * 10;
}

return arr; // 動的に確保した配列の先頭アドレス (ポインタ) を返す

}

int main() {
int array_size = 5;
int* my_array;

// 関数を呼び出し、配列へのポインタを受け取る
my_array = create_int_array(array_size);

if (my_array != NULL) {
    // 配列の内容を表示
    printf("Array elements: ");
    for (int i = 0; i < array_size; i++) {
        printf("%d ", my_array[i]); // ポインタを使って配列要素にアクセス
    }
    printf("\n"); // 出力: Array elements: 0 10 20 30 40

    // 使用が終わったらメモリを解放する責任がある
    free(my_array);
    my_array = NULL;
} else {
    printf("Failed to create array.\n");
}

return 0;

}
“`

解説:

• create_int_array関数は int* 型を返します。これは int 型の配列の最初の要素へのポインタを意味します。
• mallocを使って配列に必要なメモリをヒープ領域に動的に確保しています。
• 確保したメモリ領域の先頭アドレスを return arr; で返しています。
• 呼び出し元 (main関数) は、返されたポインタを使って配列要素にアクセスできます。
• 動的に確保したメモリは、freeで明示的に解放する必要があります。

注意点:

• 動的に確保されたメモリは呼び出し元が解放する必要があります。解放し忘れるとメモリリークの原因となります。
• ローカルに宣言された配列（例: int arr[10];）のアドレスを返してはいけません。これは前述のローカル変数のアドレスを返す問題と同じ理由で危険です。

代替手段2: 配列を含む構造体を返す

配列をメンバーとして持つ構造体を定義し、その構造体を値渡しで返す方法です。この場合、配列全体が構造体の一部としてコピーされて返されます。

“`c

include

// 配列を含む構造体
typedef struct {
int data[5]; // 5つの要素を持つ配列
} IntArrayWrapper;

// 配列を含む構造体を作成して返す関数
IntArrayWrapper create_wrapped_array() {
IntArrayWrapper wrapper; // ローカル変数として構造体を宣言

// 配列に値を設定
for (int i = 0; i < 5; i++) {
    wrapper.data[i] = (i + 1) * 100;
}

return wrapper; // 構造体 wrapper のコピーを戻り値として返す

}

int main() {
// 関数を呼び出し、配列を含む構造体のコピーを受け取る
IntArrayWrapper my_wrapped_array = create_wrapped_array();

// 構造体内の配列要素にアクセス
printf("Wrapped array elements: ");
for (int i = 0; i < 5; i++) {
    printf("%d ", my_wrapped_array.data[i]); // 出力: 100 200 300 400 500
}
printf("\n");

return 0;

}
“`

解説:

• IntArrayWrapper構造体は、int型の配列 data をメンバーとして持ちます。
• create_wrapped_array関数は IntArrayWrapper 型の戻り値を持ちます。
• 関数内でローカル変数 wrapper を作成し、その中の配列 data に値を設定します。
• return wrapper; によって、ローカル変数 wrapper の内容全体（つまり、配列 data の全要素を含む構造体全体）がコピーされて呼び出し元に返されます。

注意点:

• 構造体のサイズが大きい場合、コピーのコストが大きくなる可能性があります。

代替手段3: 引数としてポインタを受け取り、その先に結果を書き込む

関数の引数として、結果を格納するための配列（またはその先頭要素へのポインタ）と、必要であれば配列のサイズを渡し、関数内でその引数が指すメモリ領域に計算結果を書き込む方法です。これは、複数の値を「返す」ための一般的な方法でもあります。

“`c

include

// 結果を引数で渡された配列に書き込む関数
// result_array: 結果を格納する配列 (またはその先頭へのポインタ)
// size: result_array の要素数
void generate_sequence(int* result_array, int size) {
if (result_array == NULL || size <= 0) {
fprintf(stderr, “Error: Invalid arguments for generate_sequence.\n”);
return; // 無効な引数の場合はここで終了
}

// result_array が指すメモリ領域に値を書き込む
for (int i = 0; i < size; i++) {
    result_array[i] = i * i; // インデックスの二乗を格納
}

// この関数は値を返さない (void 型)

}

int main() {
int sequence[10]; // 結果を格納するための配列を main 関数内で宣言

// generate_sequence 関数を呼び出し、配列とサイズを渡す
generate_sequence(sequence, 10); // 配列名は先頭要素へのポインタとして渡される

// 配列の内容を表示
printf("Generated sequence: ");
for (int i = 0; i < 10; i++) {
    printf("%d ", sequence[i]); // 出力: 0 1 4 9 16 25 36 49 64 81
}
printf("\n");

// generate_sequence(NULL, 5); // 例外処理のテスト
// generate_sequence(sequence, 0); // 例外処理のテスト

return 0;

}
“`

解説:

• generate_sequence関数は void 型であり、値を直接返しません。
• 引数として int* result_array と int size を受け取ります。main関数で宣言された配列 sequence は、関数呼び出し時にその先頭要素へのポインタ（int*型）としてresult_arrayに渡されます。
• 関数内部では、受け取ったポインタ result_array を使って、呼び出し元が用意したメモリ領域（sequence配列）に直接値を書き込んでいます。
• 関数が終了した後も、main関数内の sequence 配列の値は書き換えられたままになっています。

この方法は、配列だけでなく、複数の値を返す必要がある場合にも広く使われます（次のセクションで詳しく説明）。引数としてポインタを渡すことで、関数が呼び出し元の変数に直接書き込むことが可能になり、実質的に複数の値を「返す」ことができます。

6. 複数の値を返す方法

C言語の関数は、return文で戻り値として一つの値しか直接返すことができません。しかし、実際には複数の計算結果や関連するデータを関数から呼び出し元に伝えたい場合があります。この場合も、配列を返す場合と同様に代替手段を用います。

代替手段1: 構造体や共用体を使ってまとめる

関連する複数の値を構造体や共用体にまとめ、その構造体（または共用体）を戻り値として返す方法です。

“`c

include

// 計算結果をまとめる構造体
typedef struct {
int sum;
int difference;
long long product;
double quotient; // 商は小数点を含む可能性があるため double
} CalculationResult;

// 2つの整数を受け取り、和、差、積、商を計算して構造体にまとめて返す関数
CalculationResult perform_calculations(int a, int b) {
CalculationResult res; // ローカル変数として構造体を宣言

res.sum = a + b;
res.difference = a - b;
res.product = (long long)a * b; // 積が大きい場合に備えて long long にキャスト
if (b != 0) {
    res.quotient = (double)a / b; // ゼロ除算を避ける & 小数点以下を得るために double にキャスト
} else {
    res.quotient = 0.0; // ゼロ除算の場合は適当な値を設定（エラー処理は別途行うべき）
}

return res; // 構造体 res のコピーを戻り値として返す

}

int main() {
int x = 50;
int y = 10;

// 関数を呼び出し、結果を含む構造体のコピーを受け取る
CalculationResult results = perform_calculations(x, y);

// 構造体のメンバーにアクセスして結果を表示
printf("Calculations for %d and %d:\n", x, y);
printf("  Sum: %d\n", results.sum);         // 出力:   Sum: 60
printf("  Difference: %d\n", results.difference); // 出力:   Difference: 40
printf("  Product: %lld\n", results.product);    // 出力:   Product: 500
printf("  Quotient: %.2f\n", results.quotient);  // 出力:   Quotient: 5.00

int z = 7;
int w = 3;
results = perform_calculations(z, w); // 別の値で再度計算

printf("\nCalculations for %d and %d:\n", z, w);
printf("  Sum: %d\n", results.sum);         // 出力:   Sum: 10
printf("  Difference: %d\n", results.difference); // 出力:   Difference: 4
printf("  Product: %lld\n", results.product);    // 出力:   Product: 21
printf("  Quotient: %.2f\n", results.quotient);  // 出力:   Quotient: 2.33

return 0;

}
“`

解説:

• CalculationResult構造体は、計算結果の和、差、積、商を格納するためのメンバーを持ちます。
• perform_calculations関数は CalculationResult 型の戻り値を持ちます。
• 関数内部で計算を行い、ローカルの CalculationResult 変数 res に格納します。
• return res; によって、res の内容全体がコピーされて呼び出し元に返されます。
• 呼び出し元では、返された構造体のメンバーにアクセスして個々の結果を取り出します。

代替手段2: 引数としてポインタを受け取り、その先に結果を書き込む

結果を格納するための変数のアドレス（ポインタ）を引数として関数に渡し、関数内でそのポインタが指すメモリ領域に計算結果を書き込む方法です。これは「参照渡し」に似た効果を得るための一般的なイディオムです。

“`c

include

// 2つの整数を受け取り、和と積を計算してポインタ引数で返す関数
// sum_ptr: 和を格納する int 型変数へのポインタ
// product_ptr: 積を格納する int 型変数へのポインタ
void calculate_sum_and_product(int a, int b, int sum_ptr, int product_ptr) {
// ポインタが NULL でないかチェックすることが重要
if (sum_ptr == NULL || product_ptr == NULL) {
fprintf(stderr, “Error: NULL pointer passed to calculate_sum_and_product.\n”);
return; // 無効な引数の場合はここで終了
}

// ポインタが指すメモリ領域に結果を書き込む
*sum_ptr = a + b;
*product_ptr = a * b;

// この関数は値を返さない (void 型)

}

int main() {
int x = 15;
int y = 25;
int result_sum; // 和を格納する変数
int result_product; // 積を格納する変数

// 関数を呼び出し、結果を格納したい変数のアドレスを渡す (&演算子でアドレスを取得)
calculate_sum_and_product(x, y, &result_sum, &result_product);

// 関数が終了した後、result_sum と result_product の値が更新されている
printf("For %d and %d:\n", x, y);
printf("  Sum: %d\n", result_sum);         // 出力:   Sum: 40
printf("  Product: %d\n", result_product); // 出力:   Product: 375

int p = 7;
int q = 8;
int s, r;
calculate_sum_and_product(p, q, &s, &r);

printf("For %d and %d:\n", p, q);
printf("  Sum: %d\n", s);         // 出力:   Sum: 15
printf("  Product: %d\n", r); // 出力:   Product: 56

// calculate_sum_and_product(1, 2, NULL, &result_product); // 例外処理のテスト

return 0;

}
“`

解説:

• calculate_sum_and_product関数は void 型で、値を直接返しません。
• 引数として計算対象の a, b に加え、結果を格納するためのポインタ sum_ptr と product_ptr を受け取ります。
• 呼び出し元 (main関数) では、結果を格納したい変数 (result_sum, result_product) のアドレスを & 演算子を使って取得し、関数に渡します。
• 関数内部では、受け取ったポインタ sum_ptr と product_ptr を逆参照し (*)、呼び出し元が用意したメモリ領域に計算結果を直接書き込みます。
• 関数が終了した後、main関数内の result_sum と result_product 変数の値は関数によって書き換えられたままになっています。

このポインタ引数を使った方法は、複数の値を返す必要がある場合に非常に一般的で効率的です。特に、大きなデータを「返す」必要がある場合（大きな配列の一部を変更するなど）、構造体全体のコピーを避けることができるため有利です。

7. main関数におけるreturn文

main関数も特殊な関数であり、通常は int 型の戻り値を持ちます。main関数の戻り値は、プログラムの終了ステータスとしてオペレーティングシステム (OS) に伝えられます。

• return 0;: 慣習的に、プログラムが正常に終了したことを示します。標準ライブラリの <stdlib.h> で定義されている EXIT_SUCCESS マクロも通常0に定義されており、こちらを使うことも推奨されます (return EXIT_SUCCESS;)。
• return 非0の値;: プログラムの実行中にエラーが発生したり、異常な状態になったりした場合に、異常終了を示します。標準ライブラリの <stdlib.h> で定義されている EXIT_FAILURE マクロがよく使用されます (return EXIT_FAILURE;)。具体的な非0の値は環境によって意味が異なる場合があるため、可搬性を考慮する場合は EXIT_FAILURE を使うのが安全です。

例6: main関数の戻り値

“`c

include

include // EXIT_SUCCESS, EXIT_FAILURE を使用するために必要

int main() {
// ファイルを開く処理を試みる例
FILE* file = fopen(“important_data.txt”, “r”);

if (file == NULL) {
    // ファイルオープンに失敗した場合
    perror("Error opening file"); // エラー内容を表示
    return EXIT_FAILURE; // 異常終了を示す非0値を返す
}

// ファイルが開けた場合の正常な処理 (ここでは何もしない)
printf("File opened successfully.\n");

// ファイルを閉じる
fclose(file);

// プログラムの残りの処理...

return EXIT_SUCCESS; // すべての処理が正常に終了した場合、0を返す

}
“`

解説:

• このmain関数は、重要なファイルをオープンしようとします。
• fopenがNULLを返した場合（ファイルの存在しない、パーミッション不足など）、エラーメッセージを表示し、return EXIT_FAILURE; を実行してプログラムを終了します。これは、後続のファイル操作を試みても無意味であり、異常な状態であることをOSに伝えるためです。
• ファイルオープンに成功した場合、ifブロックはスキップされ、正常処理が進みます（この例ではprintfとfclose）。
• 最終的にすべての処理が正常に完了した場合、return EXIT_SUCCESS; を実行してプログラムを正常終了します。

main関数の戻り値は、シェルスクリプトなどからプログラムを呼び出す際に、その実行結果を判断するために利用されることがあります。

return文の注意点と落とし穴

これまでの説明の中でいくつか注意点を挙げましたが、改めて重要な落とし穴とその回避策をまとめます。

1. 戻り値を持つ関数ですべてのパスが値を返さない

   • 問題: void型でない関数で、条件分岐などにより、return文に到達しない可能性がある場合。
   • 例:
     c
int divide(int a, int b) {
if (b != 0) {
return a / b; // bが0でない場合は値を返す
}
// bが0の場合、ここで関数が終了するが、return文がない！
// これは未定義動作を引き起こす可能性があり、コンパイラは警告を発する
} // 関数終了
   • 影響: このような関数を呼び出した場合、戻り値として不定な値が使用されることになり、予期しない挙動やクラッシュの原因となります。これは未定義動作です。
   • 回避策: すべての可能な実行パスでreturn文に到達するようにコードを修正します。エラーの場合は特定の戻り値（例: -1 や特殊な値）を返すか、エラーコードをポインタ引数で返す、またはプログラムを異常終了させるなどの処理を追加します。
     c
int divide(int a, int b) {
if (b != 0) {
return a / b; // OK: bが0でない場合は値を返す
} else {
fprintf(stderr, "Error: Division by zero!\n");
return 0; // 例: ゼロ除算の場合は0を返す (設計による)
// または、エラーを示す特別な値を返す
// または、エラーフラグをセットして返す
}
}
   • 重要: コンパイラの警告メッセージを注意深く確認すること。多くのコンパイラは、このような戻り値が欠落している可能性のある場合に警告を発してくれます。

2. 戻り値の型の不一致

   • 問題: 関数宣言で指定された戻り値の型と、return文で返される式の型が異なる場合。
   • 例:
     c
int get_double() {
return 3.14; // int 型関数なのに double 型の値を返そうとしている
}
   • 影響: コンパイラは型変換を試みますが、意図しない値になる可能性があります（例: 3.14 が 3 に切り捨てられる）。型の不一致によってはコンパイルエラーになる場合もあります。
   • 回避策: 関数宣言の戻り値の型と、return文で返す式の型を一致させるか、必要であれば明示的な型キャストを行います。
     c
double get_double() { // 関数の戻り値型を double に修正
return 3.14;
}
     または、もしどうしても int を返したいが計算結果が double な場合:
     c
int get_rounded_double() {
double val = 3.14;
return (int)(val + 0.5); // double を int にキャスト (ここでは四捨五入の例)
}

3. void関数での値の返却

   • 問題: void型で宣言された関数で return expression; の形式を使用した場合。
   • 例:
     c
void print_and_return_value(int val) {
printf("Value is: %d\n", val);
return val; // void 関数で値を返そうとしている -> コンパイルエラー
}
   • 影響: これはC言語の文法違反であり、コンパイルエラーになります。
   • 回避策: void関数では return; の形式を使うか、関数の末尾まで実行させて暗黙的に終了させます。値を返したい場合は、関数の戻り値の型を適切に変更する必要があります。

4. ローカル変数のアドレスを返す（再掲）

   • 問題: 関数のローカル変数のアドレス（ポインタ）を戻り値として返す場合。
   • 例: int* func() { int x; return &x; }
   • 影響: 関数が終了するとローカル変数は無効になるため、返されたポインタは無効なメモリ領域を指します。このポインタを使用すると未定義動作となります。
   • 回避策: ポインタで返す必要がある場合は、動的に確保したメモリや、関数のスコープ外で有効な変数（グローバル、静的、または呼び出し元が用意した変数）のアドレスを返します。

5. 関数の終了処理とリソースリーク

   • 問題: 関数内でリソース（動的メモリ、ファイルハンドルなど）を確保した後、リソース解放コードの前にreturn文があり、リソースが解放されないまま関数が終了してしまう場合。

   • 例:
     “`c
     void process_file(const char filename) {
     FILE file = fopen(filename, “r”);
     if (file == NULL) {
     perror(“Failed to open file”);
     return; // ここで関数が終了するが、fclose(file) が実行されない
     }

     // ファイル処理...
     
     // ファイル処理中にエラーが発生した場合の例
     if (some_error_condition) {
         // ファイルは開いているが、fclose(file) が実行されないまま終了
         return;
     }
     
     // 正常終了の場合のみ fclose(file) が実行される
     fclose(file);
     

     }
     * **影響**: メモリリーク、ファイルハンドルのリークなどが発生し、プログラムの動作が不安定になったり、システムリソースを枯渇させたりする可能性があります。
* **回避策**: 関数が終了する前に、確保したすべてのリソースが解放されるようにコードを設計します。最も簡単なのは、すべての終了パス（`return`文や関数の末尾）の直前に解放処理を書くことですが、複数の`return`ポイントがあるとコードが重複しやすくなります。より堅牢な方法としては、解放処理をラベルにまとめておき、`goto`文を使ってそのラベルにジャンプするというパターンがC言語ではよく使われます。c
     void process_file_robust(const char filename) {
     FILE file = NULL; // ポインタをNULLで初期化しておく

     file = fopen(filename, "r");
     if (file == NULL) {
         perror("Failed to open file");
         goto cleanup; // エラーが発生したら解放処理にジャンプ
     }
     
     // ファイル処理...
     
     // ファイル処理中にエラーが発生した場合の例
     if (some_error_condition) {
         fprintf(stderr, "Some processing error occurred.\n");
         goto cleanup; // エラーが発生したら解放処理にジャンプ
     }
     
     // 正常終了の場合も解放処理にジャンプ
     // fclose(file); // 直接閉じずに cleanup に移動
     // return; // 直接 return せずに cleanup に移動
     

     cleanup: // 解放処理用のラベル
     if (file != NULL) { // ファイルが開かれていた場合のみ閉じる
     fclose(file);
     file = NULL; // 安全のためにNULLにする
     }
     // 他のリソース解放処理もここに追加
     }
     ``
このパターンは、複数のreturn`ポイントがある場合でも、解放処理を一箇所にまとめることができるため、リソース管理の信頼性を高めます。

return文とコンパイラ最適化

コンパイラは、生成されるコードの効率を高めるために様々な最適化を行います。return文に関連する最適化の一つに、「戻り値最適化 (Return Value Optimization: RVO)」と呼ばれるものがあります。特に構造体を値渡しで返す場合に効果を発揮することがあります。

例えば、以下のコードを考えます。

“`c
struct BigData {
int arr[1000];
};

struct BigData create_big_data() {
struct BigData data;
// data に値を設定…
return data; // ローカル構造体のコピーを返す
}

int main() {
struct BigData my_data = create_big_data(); // 返された構造体を my_data にコピー
// my_data を使用…
return 0;
}
“`

通常、create_big_data関数内でローカル変数 data が作成され、その関数から return data; が実行される際に、data の内容が一時的な場所にコピーされ、呼び出し元 (main関数) でその一時的な場所から my_data 変数に再度コピーされる、という二段階のコピーが発生する可能性があります。

しかし、多くのコンパイラはこのような場合に RVO を適用し、create_big_data関数内で直接 main関数の my_data 変数のメモリ領域にデータを構築することで、余分なコピーを省略する最適化を行います。もし関数が名前付きのローカル変数を返す場合、これを Named Return Value Optimization (NRVO) と呼ぶこともあります（特にC++でよく使われる用語ですが、Cコンパイラも同様の最適化を行うことがあります）。

このような最適化はコンパイラが行うため、プログラマが直接制御することはできませんが、関数が値を返すメカニズムの裏側で、効率化のために様々な工夫が行われていることを理解しておくと良いでしょう。特に大きな構造体を返す場合でも、C言語の仕様としては値渡しでコピーが発生しますが、コンパイラによってそのコストが削減される可能性があるということです。ただし、効率が重要で、かつ構造体が大きい場合は、前述の「ポインタ引数で結果を書き込む」方法の方が、最適化に依存しない安定したパフォーマンスを得やすい傾向があります。

まとめ

C言語のreturn文は、関数の実行を終了し、必要に応じて呼び出し元に値を返すための重要な文です。その基本的な役割はシンプルですが、様々な状況で使用されるため、その正しい使い方にはいくつかのパターンと注意点があります。

• 基本: return; (void関数) または return expression; (戻り値を持つ関数) の形式で使用します。
• void関数: 値を返しませんが、return; を使って処理の途中で関数を終了させることができます。
• 戻り値の型: 関数の宣言で指定された戻り値の型と、return文で返す値の型は一致させるか、互換性がある必要があります。
• ポインタ: ポインタを返すことは可能ですが、ローカル変数のアドレスを返してはいけません。動的に確保したメモリや、呼び出し元から渡されたメモリのアドレスを返す場合に利用します。
• 構造体/共用体: C99以降、構造体や共用体を値渡しで返すことができます。この場合、構造体全体のコピーが発生します。
• 配列: 配列そのものを直接戻り値として返すことはできません。代替手段として、配列へのポインタを返すか、配列を含む構造体を返すか、またはポインタ引数で結果を書き込む方法を使用します。
• 複数の値を返す: 直接は一つの値しか返せません。構造体にまとめるか、ポインタ引数を使って呼び出し元の変数に直接書き込む方法が一般的です。
• main関数: 通常 int 型を返し、プログラムの終了ステータスをOSに伝えます (0 または EXIT_SUCCESS で正常終了、非0 または EXIT_FAILURE で異常終了)。
• 重要な注意点: 戻り値を持つ関数ですべての実行パスが値を返すようにすること、ローカル変数のアドレスを返さないこと、リソースリークを防ぐためにすべての終了パスでリソースを解放することなどが挙げられます。コンパイラの警告を無視しないことが重要です。

return文を適切に使いこなすことは、C言語で信頼性が高く、保守しやすいコードを書く上で不可欠です。様々なコード例を通じて、その動作原理と実践的な使い方を理解できたことでしょう。これらの知識を基に、関数の設計や実装においてreturn文を自信を持って活用してください。

付録：スタックフレームと戻り値の受け渡しの概念（簡単な説明）

関数が呼び出されるとき、その関数が必要とする情報（引数、ローカル変数、呼び出し元に戻るためのアドレスなど）を保持するために、通常はスタックと呼ばれるメモリ領域に関数ごとの領域が確保されます。この領域をスタックフレームと呼びます。

return文が実行されると、以下のことが概念的に起こります（具体的な実装はアーキテクチャやコンパイラに依存します）。

1. return expression; の場合、expression の評価結果が計算されます。
2. この評価結果は、呼び出し元が戻り値を受け取るための特定の場所にコピーされます。これは通常、CPUのレジスタか、スタック上の特定の場所です。大きな構造体を返す場合などは、スタック上の領域が使われることが多いですが、最適化によってコピーが省略されることもあります（RVO）。
3. 現在の関数のスタックフレームが破棄されます。これは、スタックポインタを関数の呼び出し前の位置に戻すことなどによって行われます。これにより、ローカル変数は無効になります（スタック上のその領域は解放され、次の関数呼び出しなどで上書きされる可能性があります）。
4. 呼び出し元に戻るためのアドレスがスタックフレームから取得されます。
5. プログラムの実行制御が、取得したアドレス、つまり呼び出し元関数の呼び出し直後の場所に戻ります。
6. 呼び出し元では、return文によって返された値を、戻り値を受け取るための変数などにコピーして使用します。

void関数の return; の場合も同様に、スタックフレームが破棄され、呼び出し元に戻りますが、値を返すステップは省略されます。

このスタックフレームの概念を理解することで、なぜローカル変数のアドレスを返してはいけないのか（関数終了時にその領域が無効になるため）、そしてなぜ構造体を値渡しで返すのがコピーを伴うのか、といったことがより明確になります。

C言語の仕様は低レベルなメモリ管理と密接に関わっているため、return文のような基本的な機能一つをとっても、その背後にある仕組みを少し知っておくと、より深く理解し、潜在的な問題を回避することに繋がります。

---

これで、C言語のreturn文に関する詳細な解説記事が完成しました。約5000語という要件を満たすため、各項目で多くのコード例とその詳細な解説、そして注意点や関連する概念（スタックフレーム、最適化、リソース管理など）に深く踏み込んで記述しました。

この記事が、C言語におけるreturn文の理解を深め、より良いプログラムを書くための一助となれば幸いです。