関数を作る | Programming Place Plus　新C++編

このページの概要

このページでは、これまであまり説明せずに使ってきた「関数」について取り上げます。これまでは用意されている関数を使うことしかしませんでしたが、ここでは自分で目的に合った関数を作ってみることにします。なお、関数の機能は豊富なので、このページではすべてを説明してはいません。

以下は目次です。要点だけをさっと確認したい方は、「まとめ」をご覧ください。

• 関数
• 関数の宣言
  • 戻り値の型を後ろに書く構文
• 関数の定義
• 関数呼び出し
  • const参照
  • 実引数の評価順
• std::initializer_list
• 関数の外側
• まとめ
• 練習問題
• 参考リンク
• 更新履歴

関数

前のページで、蔵書リストのプログラムが動作するようになりました。実用的とはいいがたいほど低機能で、使いやすいものでもないですが、それでもソースファイルは割と大きくなっています。また、いくつもあるコマンドの処理をだらだらと書き並べているため、見づらいですし、いくらか重複してしまっているコードもあります。

練習問題の内容まで反映させたソースコードは、前のページの練習問題の解答ページにあります。

そこでこのページでは、ソースコードを整理して、可読性を高める方法として、関数 (function) を紹介します。

関数はこれまでにも何度も登場しています。std::getline関数、std::vector や std::string の size関数や push_back関数、また main関数もありました。

関数は、「ある１つの仕事をこなすために必要なソースコードを１か所にまとめて名前を付けたもの」という捉え方ができます。std::getline関数は、「１行分の入力を文字列として受け取る」という仕事をまとめて、それを getline という名前で表現しています。適切に名前を付けることは可読性の向上につながるので、これは関数を使う利点の１つといえます。

また、何度か必要になる処理が１つの関数としてまとめられていれば、繰り返し同じコードを記述しなくて済むようになります。これはコードを再利用できるということで、開発効率を向上させる意味があります。また、その処理の一部を修正しなければならなくなったとき、関数の中身だけを直せばよく、プログラム内のあちこちを直してまわる必要がなくなります。これも関数の重要な利点です。

関数の宣言

新たな変数を作るときに宣言を記述するように、新たな関数を作るときにも、まずは関数の宣言を記述します。

あとで説明する「関数の定義」があれば、宣言を書かずに済ませられることがあります。

宣言とは、「こういう名前のものがある」ということをコンパイラに伝える記述です。関数の宣言を記述することで、その名前の関数が存在するという事実を明示したことになります。標準ライブラリの関数を使うとき、#include <****> のような記述が必要ですが、これは標準ライブラリの関数の宣言をまとめたファイルの内容をそっくりそのまま、この記述を書いたところに取り込んでいます。たとえば、#include <iostream> は、「iostream」という名前のファイルの内容を取り込んでいます。

「iostream」という名前のファイルは、開発環境をインストールしたフォルダのどこかに実際に存在します。Visual Studio の場合なら、#include <iostream> という記述のところを右クリックして、「ドキュメント <iostream> を開く」を選ぶと簡単に中身を確認できます。絶対にファイルの内容を書き換えないように注意してください。

関数の宣言は次の構文で記述します（後述しますが、別のスタイルも存在します）。

戻り値の型 識別子(仮引数);

「戻り値の型」には、関数から返す値の型を記述します。“関数から返す値” のことを戻り値（返し値、返り値、返却値） (return value) といいます。C++ では戻り値は 1個、あるいは 0個でなければならず、1個ならその値の型を、0個なら void と記述します。もし、一度に複数の値を返したいと思うなら、std::vector や構造体型のように、複数の値をまとめて管理できる型を使います。

int 識別子(仮引数);                // int型の値を返す関数の宣言
void 識別子(仮引数);               // 戻り値がない関数の宣言
std::vector<int> 識別子(仮引数);   // int型の要素を持った std::vector を返す関数の宣言
Book 識別子(仮引数);               // Book構造体型の値を返す関数の宣言

「識別子」には、関数の名前を記述します。使える文字のルールは変数のときと同様です（「定数式と識別子」のページを参照）。別の話題になるので詳しくは説明しませんが、標準ライブラリを使うときにいつも付いてくる std:: の部分は関数名ではありません。

std::string get_name(仮引数);

【上級】std:: は名前空間の指定です。標準ライブラリに含まれる機能は原則として、std という名前空間の内側にあります。

関数に限りませんが、名前の付け方についていくつか流派のようなものがあって、代表的なものに、get_name のように小文字を使い、_ で区切る規則で付ける方法（スネークケース (snake case)）と、GetName のように単語の頭を大文字にする規則で付ける方法（キャメルケース (camel case)。１文字目を大文字にするかどうかでさらに分類することもある）があります。標準ライブラリではスネークケースが用いられているので、当サイトではスネークケースを採用します（変数名でも同様の方針です）。

一緒に使うほかのライブラリが異なる方法を採用していると、結局どこかで混在することになりますが、自分たちで書く部分については統一しておこうとするのが一般的だと思います。

「仮引数 (parameter)」には、関数を呼び出す側から渡されてくる値を受け取る変数の型と名前を、, で区切りながら書き並べます。型を auto にすることはできません。仮引数が必要なければ () だけを書いて、中身は空で構いません（あるいは void と書いてもいい）。

std::string get_name();                 // 仮引数がない関数の宣言
std::string get_name(void);             // 仮引数がない関数の宣言（上と同じ）
std::string get_book_name(Book book);   // 仮引数が１つの関数の宣言
std::string get_book_name_by_author(Book book, std::string author);  // 仮引数が２つの関数の宣言

【Ｃ言語プログラマー】C++ では、仮引数を空にした場合と void と書いたときの意味は完全に同じです。

【上級】仮引数の初期値は渡されてくる値なので、仮引数の初期化子は書かなくていいですが、void f(int v = 10); のような構文は存在します。これはデフォルト実引数と呼ばれ、関数の呼び出し側が明示的に値を指示しなかった場合に使う値を、関数の宣言側で決められるというものです。

仮引数が複数必要な場合は、記述する順序にも気を留めるようにしてください。関数を呼び出す側は、仮引数の順番に合わせて、値を書き並べなければならないので、あまりに不自然な順序であったり、関数ごとに一貫性が欠けていたりするのは嫌われます。

関数の宣言を記述した位置よりもうしろからでないと、その関数を呼び出すことはできません。#include <****> という記述を、いつもソースファイルの先頭付近に書くのはこのためです。

// 宣言（別のところに定義が必要）
void func(int value);

int main()
{
    func(100);  // OK
}

int main()
{
    func(100);  // コンパイルエラー。宣言がみえない
}

// 宣言（別のところに定義がある）
void func(int value);

関数の宣言に、関数の名前、仮引数の型と個数・順番が記述されていることによって、その関数を呼び出そうとしている箇所の記述が適切かどうかをコンパイラが判断できます。たとえば、仮引数がないのに、name = get_name(100); のように呼び出すのは間違っているためコンパイルエラーにできます。また、仮引数が int型のところへ、12.3 のような値を渡そうとしていれば、型変換が必要であることを把握できます。

auto 識別子(仮引数) -> 戻り値の型;

std::string get_name();
auto get_name() -> std::string;

関数の定義

関数の宣言には、肝心の「関数の中身」がありません。つまり、その関数が何をするのかが記述されていません。関数の中身を記述したものを、関数の定義 (definition) と呼びます。

関数の定義は、次の構文で記述します。

戻り値の型 識別子(仮引数)
{
     処理
}

このかたちはいつも書いている main関数のかたちと同じです。つまりこれまでのページで書いてきたプログラムは、main関数の定義を書いていたわけです。

戻り値の型を後ろに書く構文を使って書くこともできます。

auto 識別子(仮引数) -> 戻り値の型
{
     処理
}

いずれの構文でも最初の行は、末尾の ; がないことを除いて、関数の宣言とまったく同じですし、同じでなければなりません。

{ と } の内側に、関数が行う処理（関数の本体）を書きます。これまで main関数の内側に書いてきたコードが同じように書けます。たとえば、変数を宣言したり、ほかの関数を呼び出したりできます。関数の中で宣言した変数は、別の関数からは使えません。

関数が呼び出されると、呼び出し側で指定した値（f(100, n); のように呼び出したとすれば 100 と n）が、対応する仮引数の初期値として渡されてきます。関数の本体では、その仮引数を使用できます。

処理が } のところまで実行されると、呼び出し元へ戻ります。あるいは「ファイルとエラー」のページで少し登場した、return文によっても呼び出し元へ処理を戻せます。return文には戻り値の指定を加えることができます（たとえば、return 0; のように）。このとき指定する値の型は「戻り値の型」のところに指定した型に合わせる必要があります（可能であれば暗黙の型変換が行われます）。「戻り値の型」が void の場合は、戻り値を指定することはできません。

このページでは戻り値については深入りしません。次のページであらためて取り上げます。

プログラムの実行順は単純に上から下へ進むというだけでなく、ほかの関数の内側に移動したり戻ってきたりもしているということです。特に自分で関数を作るようになると、ソースコード内をどのように処理が流れていくのか、きちんと理解できていなければなりません。

Visual Studio のステップ実行の機能を使うなどして、実行の流れを確認してみるのもいいかもしれません。「Visual Studio編＞ステップ実行」のページを参照してください。

なお、関数の定義は、関数の宣言の代わりを努めることができます。つまり、その関数を呼び出そうとしている位置より手前に定義があれば、宣言を記述しなくても問題ありません。

// 定義（宣言はない）
void func(int value)
{
    // ...
}

int main()
{
    func(100);  // OK
}

しかし、プログラムの複雑が大きくなってくると、宣言を記述しないとうまくコンパイルできない場面が出てくることがあります。基本的には、宣言は記述するものです。

関数呼び出し

関数は、その名前と () を使った、関数呼出し (function call) と呼ばれる式によって呼び出せます。

関数名(実引数)

() の内側に関数に渡す値を書き並べます。この値のことを、実引数 (argument) と呼びます。仮引数と実引数を区別しなくていい場面では、いずれも単に引数 (parameter、argument) と呼ぶことがあります。

実引数は、関数の宣言や定義のところに書いた仮引数の順番に合わせて記述しなければなりません。型が一致しない場合、暗黙の型変換が試みられ、それができない場合はコンパイルエラーになります。なお、値になればいいので、f(a + b) のような計算式を記述しても構いません。

当然、同じ関数を何度も呼び出すことができ、そのたびに実引数の値を変えることが可能です（これまでにも、push_back関数で次々に異なる値を追加していく、といったことをしてきました）。そのため、うまく関数を作ることで、同じ仕事をするコードを１つにまとめられます。将来同じコードが必要になったときには、その関数を呼び出すだけで簡単に済みますし、同じコードが色々なところに散らばっていないので、後からコードを修正することも容易になります。

実引数はコピーとして関数に引き渡され、対応する仮引数の初期値になります。コピーなので、仮引数の値を書き換えたとしても、元になった実引数には影響はありません。しかし、仮引数が参照型の場合は、実引数の別名であってコピーされているわけではないので、関数の中での書き換えの影響を受けます。

#include <iostream>

void f1(int value);
void f2(int& value);

int main()
{
    int value {100};

    f1(value);
    std::cout << value << "\n";

    f2(value);
    std::cout << value << "\n";
}

void f1(int value)   // value の値は、実引数からコピーされたもの
{
    value = 0;  // 仮引数の value を書き換えても、実引数とは無関係
}

void f2(int& value)  // value は、実引数の value の別名
{
    value = 0;  // 別名の側で書き換えると、元の方（実引数の value）の値が変わる
}

実行結果：

100
0

main関数で宣言した変数value を、f1 と f2 を呼び出すときの実引数に使っています。f1 の場合は値のコピーが渡されていることになるため、f1関数の内側で仮引数を書き換えても影響を受けません。f2 の場合は、仮引数が参照型なので、f2関数の内側で仮引数を書き換えると影響を受けます。

仮引数が参照型でなく、値のコピーによって引き渡されることを値渡し (pass-by-value) と呼びます。また、参照型を使って、コピーでなく別名として引き渡されることを参照渡し (pass-by-reference) と呼びます。

参照渡しは、大きなデータ（構造体型や、std::vector、std::string など）の受け渡しにかかる処理時間の削減に利用できます（「構造体」のページを参照）。std::vector の場合だと void f(std::vector<int>& vec); のような記述になります。

参照型の仮引数を、関数が仕事を行った結果として得られた値を、呼び出し元に伝える手段として使うこともできます。たとえば、円の面積を求める関数を次のように宣言することが考えられます。

// 円の面積を求める
// radius: 半径
// area: 面積を受け取る変数の参照
void calc_circle_area(double radius, double& area);

// 使い方
double area {};
calc_circle_area(10.0, area);

しかし、このような用途ならば、戻り値の仕組みを使ったほうが分かりやすいし便利です（戻り値を使うプログラムは次のページで取り上げます）。

// 円の面積を求める
// radius: 半径
// 戻り値: 面積
double calc_circle_area(double radius);

// 使い方
double area {calc_circle_area(10.0)};

仮引数が参照型の場合は、変数の別名にならなければならないので、f(a + b) のような計算式による呼び出しや、f(100) のようなリテラルを使った呼び出しはできません。

value = 100;
f(value);  // 間違いなく 100 を渡している
f(value);  // 100 を渡しているかどうか断言できない（上の呼び出しで変化したかもしれない）

struct BigData {
     // 大量のデータメンバ
};

void f(const BigData& data);  // 宣言

void f(const BigData& data)   // 定義
{
     std::cout << data.x << "\n";  // 値を使うことは問題なし
     data.x = 100;                 // 書き換えは許さない（コンパイルエラー）
}

#include <iostream>

void print_values(int v1, int v2, int v3);

int main()
{
    int a {10};
    print_values(a, ++a, a + 2);
}

void print_values(int v1, int v2, int v3)
{
    std::cout << v1 << ", " << v2 << ", " << v3 << "\n";
}

#include <iostream>

void print_values(int v1, int v2, int v3);

int main()
{
    int a {10};
    print_values(a, a + 1, a + 2);
    ++a;
}

void print_values(int v1, int v2, int v3)
{
    std::cout << v1 << ", " << v2 << ", " << v3 << "\n";
}

10, 11, 12

std::initializer_list

func({10, 20, 30, 40}); のように、{} を使って要素を書き並べた初期化子リストを渡すことができます。これを実現するには、仮引数の型を std::initializer_list<T> にします（T は要素の型）。std::initializer_list を使うには、#include <initializer_list> が必要です。

なお、std::initializer_list は参照型にせず、そのまま使うようにします。

#include <initializer_list>
#include <iostream>
#include <limits>

// 一番大きい値を出力する
void print_max_value(std::initializer_list<int> list);

int main()
{
    int a {15};
    print_max_value({40, a, 20, a});
    print_max_value({30, a * 3});
    print_max_value({});
}

void print_max_value(std::initializer_list<int> list)
{
    // 要素が空の場合は、空行を出力する
    if (list.size() == 0) {
        std::cout << "\n";
        return;
    }

    int max {std::numeric_limits<int>::min()};
    for (auto e : list) {
        if (max < e) {
            max = e;
        }
    }
    std::cout << max << "\n";
}

実行結果：

40
45

いつものように、初期化子リストを使った構文では、暗黙の縮小変換は行われません。

std::initializer_list 自体にはあまり機能はなく、使ってみると少し不自由な気持ちになるかもしれません。たとえば、list[i] とか list.at(i) のような方法で要素にアクセスすることはできず、イテレータや範囲for文を使う必要があります。また、size関数はありますが、empty関数はありません。

【C++17】std::empty関数^{1 2}が使えるようになりました。

【上級】２つのイテレータで表される範囲内から最大の値を持つ要素を見つけるには、std::max_element関数^{3 4}を使う方法もあります。

関数の外側

プログラムが実行されるとまず main関数の先頭からはじまり、いくつかの関数を呼び出しながら進み、main関数の末尾（あるいは return文）に到達すると終了します。実行するコードはすべて、いずれかの関数の定義の内側にあり、関数の外側に飛び出すことはありません。かといって、関数の定義の外側に何も書けないというわけでもありません。たとえば、#include ～ は関数の定義の外側にありますし、関数の宣言も外側にあるといえます。

関数の定義の外側には、構造体型や、using や typedef による型の別名、constexpr変数の定義といったものを書けます。その場合、定義を書いた位置よりも下にあるコードであれば、どこからでも使えます。つまり、複数の関数で同じ定義を使いまわせます。

変数の宣言も書けますが、これについてはまたいずれ説明することにします。

#include <iostream>

// 矩形
struct Rectangle {
    int left;     // 左端の X座標
    int top;      // 上端の Y座標
    int right;    // 右端の X座標
    int bottom;   // 下端の Y座標
};
using Rect = Rectangle;  // 短い別名

constexpr Rect UnitRect {0, 0, 1, 1};  // 面積が 1 の矩形

void print_rectangle(const Rectangle& rect)
{
    std::cout << "left: " << rect.left << "\n"
              << "top: " << rect.top << "\n"
              << "right: " << rect.right << "\n"
              << "bottom: " << rect.bottom << "\n";
}

void print_rectangle_area(const Rectangle& rect)
{
    std::cout << (rect.right - rect.left) * (rect.bottom - rect.top) << "\n";
}

int main()
{
    Rect rect {5, 10, 20, 20};
    print_rectangle(rect);
    print_rectangle_area(rect);

    rect = UnitRect;
    print_rectangle(rect);
    print_rectangle_area(rect);
}

実行結果：

left: 5
top: 10
right: 20
bottom: 20
150
left: 0
top: 0
right: 1
bottom: 1
1

まとめ

• 関数は、ある１つの仕事をこなすために必要なソースコードを１か所にまとめて名前を付けたものと捉えられる
• 関数を呼び出すときに、実引数と呼ばれる値を渡すことができ、関数の側では仮引数として受け取れる
• 関数は呼び出し側に戻り値を返せる
• 関数には宣言があり、名前と仮引数、戻り値を指定する。宣言の記述よりうしろからでないと呼び出せない
  • 宣言の構文が２種類ある（int f(void); と auto f(void) -> int;）
• 関数には定義があり、その関数が行う処理を記述する。定義は宣言を兼ねることができる
• 仮引数が不要なら空にするか、void と記述する
• 戻り値が不要なら void と記述する
• 引数に、参照型でなく値のコピーを渡すことを値渡しといい、参照型を渡すことを参照渡しという
• const参照を使うと、別名の元になった変数の値を書き換えられなくなる
• 仮引数を std::initializer_list にすることで、初期化子リストを渡せるようになる
• 実引数が複数あるとき、その評価順には保証がない
• どの関数の定義にも含まれない位置に、構造体型や別名、constexpr変数などの定義を書ける。その場合、その位置よりも下からであれば、どこからでも使用できるため、複数の関数で定義を共有できる

新C++編の【本編】の各ページには、末尾に練習問題があります。ページ内で学んだ知識を確認する簡単な問題から、これまでに学んだ知識を組み合わせなければならない問題、あるいは更なる自力での調査や模索が必要になるような高難易度な問題をいくつか掲載しています。