関数の基本

編集

関数とは何か?

編集

関数とは、プログラム内で特定のタスクや処理を実行するための独立したコードブロックを指します。関数は、コードの再利用性やメンテナンス性を高め、大規模なプログラムの作成を容易にします。また、関数はプログラムを論理的な部品に分割することで、全体の理解やデバッグを容易にする役割も果たします。

関数の定義と宣言

編集

関数の定義は、関数が何を行うかを示すコードのブロックです。関数の宣言は、関数の存在をプログラムに通知し、関数がどのような型やパラメータを持つかを指定します。C++11以降、トレイリングリターン型を使用した関数宣言が推奨されています。これにより、コードの可読性が向上し、特に複雑な型を扱う際に便利です。

トレイリングリターン型による関数の宣言と定義

編集
// 関数の宣言
auto add(int a, int b) -> int;

// 関数の定義
auto add(int a, int b) -> int {
    return a + b;
}

旧式のC言語スタイル(非推奨)

編集

旧式のC言語スタイルの関数宣言は、可読性が低く、特に複雑な戻り値の型を扱う際には混乱を招きやすいため、現代のC++プログラミングでは推奨されません。

// 非推奨: C言語スタイルの宣言と定義
int add(int a, int b) {
    return a + b;
}

関数の呼び出しと戻り値

編集

関数を呼び出すことは、その関数内のコードを実行することを意味します。関数が実行を終えると、制御は呼び出し元に戻ります。関数が戻り値を持つ場合、関数はその値を呼び出し元に返します。トレイリングリターン型を使用することで、戻り値の型が明示的に示され、コードの理解が容易になります。

auto result = add(3, 4); // 関数の呼び出し
std::cout << "結果: " << result << std::endl; // 結果: 7

パラメータと引数

編集

関数には、入力として受け取るデータを指定するためのパラメータ(仮引数)を定義できます。パラメータは関数の定義に含まれ、関数が呼び出された際に引数(実引数)として渡される値を受け取ります。トレイリングリターン型を使うことで、複雑なパラメータと戻り値の組み合わせも明確に記述できます。

// 関数の定義
auto printSum(int a, int b) -> void {
    auto sum = a + b;
    std::cout << "合計: " << sum << std::endl;
}

// 関数の呼び出し
printSum(5, 7); // 出力: 合計: 12

トレイリングリターン型の利点

編集
可読性の向上
戻り値の型が関数名の後に明示されるため、コードの読みやすさが向上します。
一貫性
ラムダ式やautoキーワードと一貫性があり、モダンC++のスタイルに適合します。
複雑な型の扱いやすさ
テンプレートや複雑な戻り値の型を持つ関数に対して特に有効です。
まとめ

トレイリングリターン型を使用することで、モダンC++の機能を最大限に活用し、コードの可読性と保守性を高めることができます。旧式のC言語スタイルは混乱を招きやすく、特に複雑な型を扱う場合には避けるべきです。モダンなC++プログラミングにおいては、トレイリングリターン型を積極的に採用することを強くお勧めします。

関数の種類

編集

戻り値のない関数

編集

戻り値のない関数は、結果を返さずに実行される関数です。主に何らかの処理を行うために使用されます。このような関数は、返り値の型としてvoidを指定します。例えば、画面にメッセージを表示する関数や、ファイルにデータを書き込む関数などが戻り値のない関数の一例です。

auto printMessage() -> void {
    std::cout << "Hello, World!" << std::endl;
}

パラメータのない関数

編集

パラメータのない関数は、呼び出し時に引数を必要としない関数です。関数の定義には引数のリストが含まれません(C23より前のCでは明示的に void と書かないとパラメータ不明な関数でしたが、C++では何も書かなければパラメータがゼロ個な関数です)。この種類の関数は、特定の条件や状態を必要とせずに、単純な処理を実行する際に使用されます。例えば、現在の日付や時刻を取得する関数などがパラメータのない関数の一例です。

auto getCurrentTime() -> std::string {
    auto t = std::time(nullptr);
    auto tm = *std::localtime(&t);
    std::ostringstream oss;
    oss << std::put_time(&tm, "%Y-%m-%d %H:%M:%S");
    return oss.str();
}

戻り値とパラメータの両方を持つ関数

編集

戻り値とパラメータの両方を持つ関数は、関数が呼び出し元に値を返すだけでなく、関数の実行に必要な情報を引数として受け取る場合に使用されます。これらの関数は、複雑な処理を行う場合や、外部のデータを受け取ってそれを処理する場合に適しています。例えば、数値の加算を行う関数や、文字列の長さを返す関数などがこの種類の関数です。

auto add(int a, int b) -> int {
    return a + b;
}

auto getStringLength(const std::string& str) -> std::size_t {
    return str.length();
}

再帰関数

編集

再帰関数は、関数内で自身を呼び出す関数のことです。再帰関数は通常、同じ問題をより小さい部分に分割し、それを解決するために自身を再帰的に呼び出す場合に使用されます。再帰関数は、アルゴリズムの実装やデータ構造の操作など、特定の問題に対する効果的な解決法を提供する場合があります。

auto factorial(int n) -> int {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

これらの関数の種類は、さまざまなプログラム設計や問題解決の方法を提供し、適切に使用することでコードの効率性と可読性を大幅に向上させます。トレイリングリターン型を使用することで、関数の宣言と定義が明確になり、複雑な型や再帰的な定義も扱いやすくなります。

関数オーバーロード

編集

関数オーバーロードの概要

編集

関数オーバーロードとは、同じ名前の関数が複数定義され、それぞれが異なる引数リストを持つことです。C++では、関数名が同じでも引数の数や型が異なれば、異なる関数として扱われます。関数オーバーロードにより、同じ名前の関数を使って、複数のタイプやデータ構造に対応することができます。

オーバーロード解決のルール

編集

関数オーバーロードの際には、呼び出し元で使用される引数のリストに一致する最も適切な関数が選択されます。オーバーロード解決のルールは次のようになります。

  1. 引数の数が一致する場合、引数の型が最も正確に一致する関数が選択されます。
  2. 引数の型が一致する関数が複数存在する場合、その引数の型がより具体的な関数が選択されます。
  3. キャストが必要な場合、最も少ないキャストが必要な関数が選択されます。

オーバーロードの例

編集
#include <iostream>

// int型の引数を受け取る関数
auto print(int num) -> void {
    std::cout << "Integer: " << num << std::endl;
}

// double型の引数を受け取る関数
auto print(double num) -> void {
    std::cout << "Double: " << num << std::endl;
}

// 文字列型の引数を受け取る関数
auto print(const std::string& str) -> void {
    std::cout << "String: " << str << std::endl;
}

auto main() -> int {
    print(5);         // int型の関数が呼び出される
    print(3.14);      // double型の関数が呼び出される
    print("Hello");   // 文字列型の関数が呼び出される

    return 0;
}

この例では、という関数がオーバーロードされています。関数は、整数型、浮動小数点型、および文字列型の引数を受け取る3つのバージョンがあります。関数では、整数、浮動小数点数、および文字列を引数として関数を呼び出していますが、それぞれ適切な型の関数が選択されて呼び出されます。

まとめ

関数オーバーロードは、同じ名前の関数を異なる引数リストで複数定義することで、さまざまなデータ型や状況に対応する柔軟なインターフェースを提供します。オーバーロード解決のルールを理解し、適切な関数を選択できるようにすることは、効果的なC++プログラミングの重要なスキルです。トレイリングリターン型を使うことで、関数の宣言がより明確になり、読みやすさも向上します。

デフォルト引数

編集

デフォルト引数の利点と構文

編集

デフォルト引数は、関数の引数に初期値を設定することができる機能です。これにより、関数を呼び出す際に引数を省略することができ、デフォルト値が自動的に使用されます。デフォルト引数を使用することで、関数の呼び出しを簡略化し、コードの可読性を向上させることができます。

デフォルト引数の構文は、関数の引数リストで初期値を設定することです。例えば、以下のように定義します。

auto myFunction(int x, int y = 10, int z = 20) -> void {
    // 関数の本体
}

上記の例では、myFunctionという関数が定義されています。この関数は、最初の引数xは必須で、yzはデフォルト値を持ちます。yのデフォルト値は10、zのデフォルト値は20です。

デフォルト引数の注意点

編集

デフォルト引数を使用する際には、いくつかの注意点があります。まず、デフォルト引数は、関数の定義または宣言のどちらか一方で指定する必要があります。また、デフォルト引数は、右側から順に指定される必要があります。つまり、右側の引数からデフォルト値を指定し、左側の引数にデフォルト値を指定することはできません。

また、デフォルト引数を持つ関数のオーバーロードも考慮する必要があります。複数の関数が同じ名前を持つ場合、それぞれの関数に異なるデフォルト引数を指定することができます。しかし、オーバーロード解決の際には、最も適切な関数を選択するために引数の型と数が考慮されます。

デフォルト引数の使用例

編集
#include <iostream>

// デフォルト引数を持つ関数の定義
auto greet(std::string name = "Guest") -> void {
    std::cout << "Hello, " << name << "!" << std::endl;
}

auto main() -> int {
    // デフォルト引数を使用して関数を呼び出す
    greet();         // "Hello, Guest!" と表示される
    greet("Alice");  // "Hello, Alice!" と表示される

    return 0;
}

この例では、greetという関数が定義されています。この関数は、引数nameのデフォルト値を"Guest"としています。main関数では、greet関数を引数なしで呼び出すとデフォルト値が使用され、引数を指定して呼び出すとその値が使用されます。

複数のデフォルト引数を持つ関数

編集

複数のデフォルト引数を持つ関数も定義できます。以下に例を示します。

#include <iostream>

// 複数のデフォルト引数を持つ関数の定義
auto displayInfo(std::string name, int age = 0, std::string city = "Unknown") -> void {
    std::cout << "Name: " << name << ", Age: " << age << ", City: " << city << std::endl;
}

auto main() -> int {
    // デフォルト引数を使用して関数を呼び出す
    displayInfo("Bob");                         // Name: Bob, Age: 0, City: Unknown
    displayInfo("Alice", 30);                   // Name: Alice, Age: 30, City: Unknown
    displayInfo("Charlie", 25, "New York");     // Name: Charlie, Age: 25, City: New York

    return 0;
}

この例では、displayInfoという関数が定義されています。この関数は、nameagecityの3つの引数を持ち、agecityにデフォルト値が設定されています。main関数では、引数を部分的に省略してdisplayInfo関数を呼び出すことができ、指定されなかった引数にはデフォルト値が使用されます。

デフォルト引数をうまく活用することで、柔軟で読みやすいコードを書くことができます。特に、関数の呼び出しを簡潔にし、コードのメンテナンス性を向上させることができます。

参照渡しとポインタ渡し

編集

値渡しと参照渡しの違い

編集

値渡しは、関数に引数として渡される値のコピーが関数内で作成されます。これに対して、参照渡しは、関数に引数として渡される変数のアドレスが関数に渡され、その変数に対する直接のアクセスが可能となります。値渡しでは、関数内での変数の変更は呼び出し元の変数に影響を与えませんが、参照渡しでは関数内での変更が呼び出し元の変数に反映されます。

#include <iostream>

auto passByValue(int value) -> void {
    value = 100;
}

auto passByReference(int& ref) -> void {
    ref = 100;
}

auto main() -> int {
    int a{10};
    int b{10};

    passByValue(a);
    passByReference(b);

    std::cout << "a (pass by value): " << a << std::endl; // 10
    std::cout << "b (pass by reference): " << b << std::endl; // 100

    return 0;
}

この例では、passByValue関数は値渡し、passByReference関数は参照渡しを使用しています。aの値は変更されませんが、bの値は変更されています。

ポインタ渡しと参照渡しの比較

編集

ポインタ渡しと参照渡しは、両方とも関数に変数のアドレスを渡すことができますが、その違いは主に構文とセマンティクスにあります。ポインタ渡しでは、関数定義と呼び出し時にポインタ演算子*とアドレス演算子&を使用する必要がありますが、参照渡しではこれらの演算子を使用する必要はありません。また、参照渡しではヌルポインタのチェックが不要であり、より安全です。

#include <iostream>

auto passByPointer(int* ptr) -> void {
    if (ptr != nullptr) {
        *ptr = 100;
    }
}

auto main() -> int {
    int a{10};
    int* b{nullptr};

    passByPointer(&a);
    passByPointer(b);

    std::cout << "a (pass by pointer): " << a << std::endl; // 100

    return 0;
}

この例では、passByPointer関数はポインタ渡しを使用しています。aの値は変更されますが、ヌルポインタbに対しては安全に処理されています。

ポインタと参照の選択基準

編集

ポインタと参照の選択基準は、プログラムの要件や設計上の考慮事項によって異なります。一般的なガイドラインとしては、以下の点が挙げられます。

  • ポインタは、関数内でNULL値を許容する必要がある場合や、動的なメモリ管理が必要な場合に適しています。一方、参照はNULL値を許容せず、常に有効なオブジェクトを参照するために使用されます。
  • 参照は、ポインタよりも単純で直感的な構文を提供し、プログラムの読みやすさを向上させます。そのため、可読性や保守性を重視する場合には参照を選択することが一般的です。
  • 関数の引数としてオブジェクトを渡す際に、オブジェクトを変更する必要がある場合には参照を使用します。一方、オブジェクトを変更しない場合や、オブジェクトがNULLである可能性がある場合にはポインタを使用します。

これらの基準を考慮して、ポインタと参照を使い分けることで、効果的なプログラム設計を行うことができます。

ラムダ式と無名関数

編集

ラムダ式の概要

編集

ラムダ式は、匿名の関数を定義するための機能であり、関数オブジェクトとして扱われます。C++11から導入された機能であり、関数をインラインで定義し、その場で使用することができます。ラムダ式は、簡潔で直感的な記法を提供し、コードの可読性と書きやすさを向上させます。

ラムダ式の使用法と構文

編集

ラムダ式は、次のような構文を持ちます。

[ キャプチャリスト ] ( パラメータリスト ) -> 戻り値型 { 本体 }
キャプチャリスト
ラムダ式が外部の変数を参照する場合に使用します。ラムダ式内で変数を使用する際に、その変数をラムダ式にキャプチャする必要があります。キャプチャリストは、ラムダ式がどの変数をキャプチャするかを指定します。
パラメータリスト
ラムダ式の引数リストです。関数の引数と同様に、必要な引数を指定することができます。
戻り値型
ラムダ式が返す値の型です。省略可能であり、省略するとコンパイラが自動的に返り値の型を推論します。
本体
ラムダ式の本体です。関数の処理を記述します。

以下は、ラムダ式の簡単な例です。

#include <iostream>

auto main() -> int {
    // ラムダ式を使った関数オブジェクトの定義と呼び出し
    auto add = [](int x, int y) { return x + y; };
    std::cout << add(3, 5) << std::endl;  // 出力: 8

    return 0;
}

キャプチャリスト

編集

キャプチャリストは、ラムダ式が外部の変数を参照する方法を指定します。キャプチャリストには、次のような種類があります。

[]
キャプチャなし。ラムダ式内で外部の変数を使用できません。
[&]
ラムダ式が参照する外部の変数を参照キャプチャします。参照キャプチャを使用すると、ラムダ式内で外部の変数の値を変更することができます。
[=]
ラムダ式が参照する外部の変数を値キャプチャします。値キャプチャを使用すると、ラムダ式内で外部の変数の値を変更することはできません。

以下は、キャプチャリストを使用した例です。

#include <iostream>

auto main() -> int {
    int x{5};
    auto func1 = [&]() { return x + 1; }; // xを参照キャプチャ
    auto func2 = [=]() { return x + 1; }; // xを値キャプチャ

    x = 10;

    std::cout << func1() << std::endl; // 出力: 11
    std::cout << func2() << std::endl; // 出力: 6

    return 0;
}

この例では、func1xを参照キャプチャしているため、xの変更が反映され、func2xを値キャプチャしているため、xの変更が反映されません。

関数テンプレート

編集

テンプレートの概要

編集

関数テンプレートは、異なるデータ型や値に対して汎用的な処理を行うための機能です。テンプレートを使用することで、同じコードを異なるデータ型や値に対して再利用することができます。C++において、関数テンプレートは、ジェネリックプログラミングの手法の一部として広く利用されています。

テンプレート関数の定義と使用法

編集

テンプレート関数は、次のような構文を持ちます。

template <typename T>
T myFunction(T x, T y) {
    return x + y;
}

このように、templateキーワードとtypenameまたはclassキーワードを使用して、テンプレートパラメータを定義します。Tはテンプレートパラメータであり、任意のデータ型を指定することができます。関数内では、Tを通じてジェネリックな処理を行うことができます。

テンプレート関数を使用する際には、次のようにして呼び出します。

int result1 = myFunction(3, 5);         // int型の場合
double result2 = myFunction(3.5, 5.5); // double型の場合

引数として与えるデータ型に応じて、適切なテンプレートインスタンスが生成されます。

テンプレートの特殊化

編集

テンプレートの特殊化は、特定のデータ型に対してカスタム処理を提供するための機能です。一般的なテンプレート関数に加えて、特定のデータ型に対する特殊なバージョンを提供することができます。これにより、特殊なデータ型に対して最適化された処理を行うことができます。

// int型に特殊化されたテンプレート関数
template <>
int myFunction<int>(int x, int y) {
    return x * y;
}

上記の例では、int型に特殊化されたmyFunction関数が定義されています。この関数は、int型の引数に対して掛け算を行います。特殊化されたテンプレート関数は、通常のテンプレート関数と同様に使用されますが、特定のデータ型に対して優先的に選択されます。

関数と型推論

編集

C++は複雑な型システムを持ち、コードの安全性と可読性を向上させるために型推論の機能を提供しています。特に、関数の引数や戻り値、ラムダ式において型推論を活用することができます。C++11以降の規格で導入されたこれらの機能を利用することで、より簡潔でメンテナンスしやすいコードを書くことが可能です。

引数の型推論

編集

関数の引数に対する型推論は、C++20で導入されたコンセプトを使用することで実現できます。テンプレートを使用して、関数の引数の型を自動的に推論することができます。

#include <iostream>
#include <type_traits>

// C++20以降での型推論を使用した関数テンプレート
template<typename T>
auto printValue(T value) -> void {
    std::cout << value << std::endl;
}

auto main() -> int {
    printValue(42);        // int型を推論
    printValue(3.14);      // double型を推論
    printValue("Hello");   // const char*型を推論

    return 0;
}

この例では、printValue関数はテンプレートを使用して引数の型を推論します。テンプレートの引数Tが、自動的に渡された引数の型に置き換えられます。

戻り値の型推論

編集

戻り値の型推論は、C++14で導入された機能です。autoキーワードを使用して、関数の戻り値の型をコンパイラに推論させることができます。これにより、関数の宣言が簡潔になり、コードの可読性が向上します。

#include <iostream>

// 戻り値の型推論を使用した関数
auto add(int a, int b) -> auto {
    return a + b;
}

auto main() -> int {
    std::cout << add(5, 3) << std::endl;  // 8 と表示される

    return 0;
}

この例では、add関数の戻り値の型をautoとし、コンパイラに型推論を任せています。

ラムダ式の型推論

編集

ラムダ式は、C++11で導入された匿名関数の一種です。ラムダ式では、引数や戻り値の型を省略することができ、コンパイラが自動的に推論してくれます。ラムダ式の型推論を利用することで、コードがより簡潔になります。

#include <iostream>
#include <vector>
#include <algorithm>

auto main() -> int {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // ラムダ式を使用してベクトルの各要素を2倍にする
    std::for_each(numbers.begin(), numbers.end(), [](auto& n) {
        n *= 2;
    });

    for (const auto& n : numbers) {
        std::cout << n << " ";  // 2 4 6 8 10 と表示される
    }

    std::cout << std::endl;

    return 0;
}

この例では、ラムダ式の引数nの型をautoとしています。コンパイラはnの型を自動的に推論し、適切な型として扱います。また、戻り値も型推論で暗黙にintが推論されます。

まとめ

C++11以降の規格で導入された型推論の機能を活用することで、関数の引数や戻り値、ラムダ式の型を明示的に指定する必要がなくなり、コードがより簡潔で可読性の高いものになります。特に、C++14のauto戻り値型推論やC++20のコンセプトを使用することで、複雑な型を扱う場合でもシンプルなコードを書くことができます。これらの機能を積極的に利用することで、よりメンテナブルで効率的なプログラムを作成することができます。

型推論を用いるとテンプレートを使わずジェネリックプログラミングができる
型推論を使用することで、テンプレートを使わずにジェネリックプログラミングを行うことができます。これは、C++11以降で導入されたautoキーワードや、C++14以降で導入されたdecltypeキーワードなどを活用することで実現されます。

例えば、autoキーワードを使用することで、関数テンプレートを定義せずにジェネリックな関数を作成することができます。以下にその例を示します。

#include <iostream>

// ジェネリックな関数を定義
auto add(auto a, auto b) {
    return a + b;
}

auto main() -> int {
    auto result1 = add(5, 3);       // int型として推論される
    auto result2 = add(3.14, 2.5);  // double型として推論される

    std::cout << "Result 1: " << result1 << std::endl; // 8
    std::cout << "Result 2: " << result2 << std::endl; // 5.64

    return 0;
}

この例では、add関数はautoキーワードを使用して引数と戻り値の型を推論しています。そのため、関数がジェネリックになり、さまざまな型の引数を受け取ることができます。

同様に、decltypeキーワードを使用して変数の型を推論することもできます。以下にその例を示します。

#include <iostream>

auto main() -> int {
    int x{5};
    decltype(x) y = 10;  // 変数xと同じ型(int型)としてyの型が推論される

    std::cout << "Value of y: " << y << std::endl; // 10

    return 0;
}

この例では、decltype(x)を使用して変数yの型を変数xと同じ型として推論しています。このように、decltypeキーワードを使用することで、変数の型を他の式や変数から推論することができます。

これらの型推論機能を組み合わせて使うことで、テンプレートを使わずにジェネリックなプログラミングを行うことができます。これにより、コードがより簡潔で読みやすくなり、プログラムの保守性が向上します。

標準ライブラリの関数

編集

algorithm ライブラリの関数

編集

algorithm ライブラリには、STL(Standard Template Library)の一部として、さまざまな便利な関数が含まれています。主な関数のいくつかを以下に示します。

std::sort()
コンテナ内の要素をソートします。
std::find()
コンテナ内で指定された値を検索します。
std::count()
コンテナ内で指定された値の出現回数を数えます。
std::accumulate()
コンテナ内の要素を合計します。
std::transform()
コンテナ内の要素に対して変換を適用します。

functional ライブラリの関数

編集

functional ライブラリは、関数オブジェクトを操作するためのユーティリティ関数を提供します。主な関数のいくつかを以下に示します。

std::function
任意の関数や関数オブジェクトをラップし、関数型として使用するためのクラスです。
std::bind
関数の一部の引数を固定し、新しい関数を作成します。
std::plus, std::minus, std::multiplies, std::divides
二項演算を行う関数オブジェクトです。
std::greater, std::less
比較を行う関数オブジェクトです。

その他の標準ライブラリ関数の利用法

編集

その他の標準ライブラリ関数を利用するには、適切なヘッダファイルをインクルードし、関数を呼び出すだけです。例えば、std::sort関数を使用する場合、<algorithm>ヘッダをインクルードします。

#include <iostream>
#include <algorithm>
#include <vector>

auto main() -> int {
    std::vector<int> vec = {3, 1, 4, 1, 5, 9, 2, 6};

    // ソート
    std::sort(vec.begin(), vec.end());

    // 結果を表示
    for (const auto& elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

このように、標準ライブラリ関数を利用することで、効率的で信頼性の高いコードを書くことができます。

C++11以降の関数関係の機能追加

編集

C++11以降では、関数に関する機能や新しいスタイルがいくつか導入されています。以下にいくつかの主な機能を紹介します。

ラムダ式(Lambda Expressions)
C++11では、ラムダ式が導入されました。これは、簡潔な匿名関数を定義するための構文です。ラムダ式は、関数オブジェクトを簡単に定義し、スコープ内で即座に使用することができます。
    auto func = [](auto x, auto y) { return x + y; };
    auto result = func(3, 4);  // 7
std::functionstd::bind
std::functionは、任意の呼び出し可能なターゲット(関数、関数オブジェクト、ラムダ式など)を保持するための汎用的なクラステンプレートです。std::bindは、関数やメンバ関数の呼び出しを部分的に適用するためのツールです。
    #include <functional>
    #include <iostream>

    void foo(int x, int y) {
        std::cout << "Sum: " << x + y << std::endl;
    }

    auto main() -> int {
        auto f = std::bind(foo, 10, std::placeholders::_1);
        f(20);  // Sum: 30

        return 0;
    }
右辺値参照と移動セマンティクス(Rvalue References and Move Semantics)
C++11では、右辺値参照と移動セマンティクスが導入されました。これにより、一時オブジェクトの所有権を効率的に移動できるようになり、効率的なメモリ管理やオブジェクトのパフォーマンスの向上が可能になりました。
    #include <iostream>
    #include <vector>

    auto main() -> int {
        std::vector<int> v1 = {1, 2, 3};
        std::vector<int> v2 = std::move(v1);  // v1の所有権がv2に移動される

        return 0;
    }
constexpr関数
constexpr修飾子を使って関数を宣言することで、コンパイル時に評価される定数式として使用できる関数を定義できます。これにより、コンパイル時の計算が可能になり、実行時のオーバーヘッドが軽減されます。
    constexpr int factorial(int n) {
        return n <= 1 ? 1 : n * factorial(n - 1);
    }

    auto main() -> int {
        constexpr int result = factorial(5);  // コンパイル時に評価される
        return 0;
    }
デフォルト関数と削除関数
= defaultおよび= deleteキーワードを使用して、デフォルトのコンストラクタやデストラクタを明示的に指定することができます。また、= deleteを使用して、意図的に特定の関数の定義を削除することもできます。
    class MyClass {
     public:
        // デフォルトのコンストラクタ
        MyClass() = default;

        // コピーコンストラクタを削除
        MyClass(const MyClass&) = delete;
    };
consteval関数
constevalはC++20で導入されたキーワードで、constexpr関数の一種ですが、コンパイル時に実行されることが保証される点で異なります。constevalを使用することで、コンパイル時に実行される関数を定義することができます。これにより、プログラムのパフォーマンスやセキュリティを向上させることができます。
以下は、constevalを使用して素数を判定する関数を定義する例です。
#include <iostream>

// トレイリングリターン型を使った素数判定関数
consteval auto is_prime(int n) -> bool {
    if (n <= 1) return false;
    if (n <= 3) return true;
    if (n % 2 == 0 || n % 3 == 0) return false;
    for (int i = 5; i * i <= n; i += 6) {
        if (n % i == 0 || n % (i + 2) == 0) return false;
    }
    return true;
}

auto main() -> int {
    constexpr auto num{17};

    if (constexpr bool result = is_prime(num); result) {
        std::cout << num << " is a prime number." << std::endl;
    } else {
        std::cout << num << " is not a prime number." << std::endl;
    }

    return 0;
}
この例では、is_prime関数がconstevalで修飾されています。そのため、この関数はコンパイル時に実行され、結果はコンパイル時に評価されます。constexpr修飾子を使用して変数numを定義し、この変数をis_prime関数の引数として使用しています。コンパイル時にis_prime関数が評価され、結果が定数式として求められます。その結果、変数resultはコンパイル時に確定され、実行時には不変の値となります。
このように、constevalを使用することで、コンパイル時に実行される関数を定義し、実行時のオーバーヘッドを避けることができます。これにより、効率的なコードを記述し、パフォーマンスの向上やセキュリティの確保を実現することができます。

これらの機能やスタイルの導入により、C++の関数や関数に関連するコードの記述がより簡潔で効率的になり、より安全で柔軟なプログラミングが可能になりました。

例題と演習

編集

簡単な問題から応用問題までの一連の演習

編集
簡単な問題
整数の配列が与えられたとき、その配列の要素の合計を計算する関数を作成してください。
中級レベルの問題
与えられた文字列が回文(前から読んでも後ろから読んでも同じ)かどうかを判定する関数を実装してください。
応用問題
フィボナッチ数列の第n項を計算する関数を再帰的に実装してください。ただし、この関数の計算時間が指数時間になることを避けるために、適切な方法で最適化してください。

回答例

編集
#include <iostream>
#include <cassert>

// 例題1の関数: 配列の合計を計算する関数
int sumArray(const int arr[], int size) {
    int sum = 0;
    for (int i = 0; i < size; ++i) {
        sum += arr[i];
    }
    return sum;
}

// 例題2の関数: 回文かどうかを判定する関数
bool isPalindrome(const std::string& str) {
    int left = 0;
    int right = str.length() - 1;

    while (left < right) {
        if (str[left] != str[right]) {
            return false;
        }
        ++left;
        --right;
    }
    return true;
}

// 例題3の関数: フィボナッチ数列の第n項を計算する関数
int fibonacci(int n) {
    if (n <= 1) {
        return n;
    }
    return fibonacci(n - 1) + fibonacci(n - 2);
}

auto main() -> int {
    // 例題1のテスト
    int arr[] = {1, 2, 3, 4, 5};
    assert(sumArray(arr, 5) == 15);

    // 例題2のテスト
    assert(isPalindrome("radar") == true);
    assert(isPalindrome("hello") == false);

    // 例題3のテスト
    assert(fibonacci(6) == 8);

    std::cout << "All tests passed!" << std::endl;
    return 0;
}

このプログラムでは、各関数をテストするために assert() マクロが使用されています。各関数が期待どおりに動作するかどうかを確認するために、適切な入力でテストを行います。