[C++] 型が関数かどうかを判定する方法

#include <iostream>
#include <type_traits>
// 関数の宣言
void exampleFunction() {}
int main() {
    // exampleFunctionが関数型かどうかを判定
    if (std::is_function<decltype(exampleFunction)>::value) {
        std::cout << "exampleFunctionは関数型です。" << std::endl;
    } else {
        std::cout << "exampleFunctionは関数型ではありません。" << std::endl;
    }
    return 0;
}

exampleFunctionは関数型です。

#include <iostream>
#include <type_traits>
int main() {
    // int型とdouble型の比較
    if (std::is_same<int, double>::value) {
        std::cout << "intとdoubleは同じ型です。" << std::endl;
    } else {
        std::cout << "intとdoubleは異なる型です。" << std::endl;
    }
    return 0;
}

intとdoubleは異なる型です。

#include <iostream>
#include <typeinfo>
int main() {
    int a = 10;
    decltype(a) b = 20; // aと同じ型の変数bを宣言
    // bの型情報を取得
    std::cout << "bの型は: " << typeid(b).name() << std::endl;
    return 0;
}

bの型は: i

#include <iostream>
#include <type_traits>

// 関数の宣言
void exampleFunction() {}

int main() {
    // 関数ポインタの宣言
    void (*funcPtr)() = exampleFunction;

    // funcPtrが指す関数の型が関数型かどうかを判定
    if (std::is_function<decltype(*funcPtr)>::value) {
        std::cout << "funcPtrは関数型を指しています。" << std::endl;
    } else {
        std::cout << "funcPtrは関数型を指していません。" << std::endl;
    }
    return 0;
}

#include <iostream>
#include <type_traits>
class MyClass {
public:
    void memberFunction() {}
};
int main() {
    // メンバ関数ポインタの宣言
    void (MyClass::*memFuncPtr)() = &MyClass::memberFunction;
    // memFuncPtrがメンバ関数ポインタかどうかを判定
    if (std::is_member_function_pointer<decltype(memFuncPtr)>::value) {
        std::cout << "memFuncPtrはメンバ関数ポインタです。" << std::endl;
    } else {
        std::cout << "memFuncPtrはメンバ関数ポインタではありません。" << std::endl;
    }
    return 0;
}

memFuncPtrはメンバ関数ポインタです。

#include <iostream>
#include <type_traits>
int main() {
    // ラムダ式の宣言
    auto lambda = []() { std::cout << "Hello, Lambda!" << std::endl; };
    // lambdaが関数型かどうかを判定
    if (std::is_function<decltype(lambda)>::value) {
        std::cout << "lambdaは関数型です。" << std::endl;
    } else {
        std::cout << "lambdaは関数型ではありません。" << std::endl;
    }
    return 0;
}

lambdaは関数型ではありません。

#include <iostream>
#include <type_traits>
// テンプレート関数の宣言
template<typename T>
void process(T value) {
    if (std::is_integral<T>::value) {
        std::cout << "整数型の処理: " << value << std::endl;
    } else {
        std::cout << "非整数型の処理: " << value << std::endl;
    }
}
int main() {
    process(42);      // 整数型
    process(3.14);    // 非整数型
    return 0;
}

整数型の処理: 42
非整数型の処理: 3.14

#include <iostream>
#include <type_traits>
// 型安全な関数の宣言
template<typename T>
void safeCall(T func) {
    static_assert(std::is_function<T>::value, "引数は関数型でなければなりません");
    func();
}
// サンプル関数
void sampleFunction() {
    std::cout << "関数が呼び出されました。" << std::endl;
}
int main() {
    safeCall(sampleFunction); // 正しい呼び出し
    // safeCall(42); // コンパイルエラー: 引数は関数型でなければなりません
    return 0;
}

関数が呼び出されました。

#include <iostream>
#include <functional>
// ストラテジーパターンの実装
class Context {
public:
    void setStrategy(std::function<void()> strategy) {
        this->strategy = strategy;
    }
    void executeStrategy() {
        if (strategy) {
            strategy();
        }
    }
private:
    std::function<void()> strategy;
};
// サンプル戦略
void strategyA() {
    std::cout << "戦略Aが実行されました。" << std::endl;
}
void strategyB() {
    std::cout << "戦略Bが実行されました。" << std::endl;
}
int main() {
    Context context;
    context.setStrategy(strategyA);
    context.executeStrategy();
    context.setStrategy(strategyB);
    context.executeStrategy();
    return 0;
}

戦略Aが実行されました。
戦略Bが実行されました。