[C++] クラスと関数を使い分けるポイントを解説

C++では、クラスと関数を使い分けるポイントは設計の意図やデータの管理方法に依存します。

クラスはデータとその操作を一体化して管理するために使用され、オブジェクト指向プログラミングの基本単位です。

データの状態を保持し、複数の関連する操作をまとめたい場合にクラスを使います。

一方、関数は特定の処理を行うための単位で、データの状態を持たず、入力に対して出力を返すことが主な役割です。

この記事でわかること

クラスと関数の基本的な役割
クラスを使うべきケース
関数を使うべきケース
クラスと関数の併用方法
応用例における使い分け

目次から探す

クラスと関数の基本的な役割

クラスとは何か

クラスは、データとそのデータに関連する操作を一つにまとめた構造体のようなものです。

C++では、クラスを使ってオブジェクト指向プログラミングを行うことができます。

クラスは、属性(データメンバー)とメソッド(関数メンバー)を持ち、オブジェクトを生成するための設計図として機能します。

以下は、クラスの基本的な例です。

#include <iostream>
using namespace std;
class Car {
public:
    string brand; // 車のブランド
    int year;     // 製造年
    void displayInfo() { // 車の情報を表示するメソッド
        cout << "ブランド: " << brand << ", 年: " << year << endl;
    }
};
int main() {
    Car myCar; // Carクラスのオブジェクトを生成
    myCar.brand = "トヨタ"; // ブランドを設定
    myCar.year = 2020;      // 年を設定
    myCar.displayInfo();    // 車の情報を表示
    return 0;
}

ブランド: トヨタ, 年: 2020

関数とは何か

関数は、特定の処理を実行するための独立したコードのブロックです。

関数は、引数を受け取り、処理を行い、結果を返すことができます。

C++では、関数を使ってコードの再利用性を高めたり、プログラムの構造を整理したりします。

以下は、関数の基本的な例です。

#include <iostream>
using namespace std;
int add(int a, int b) { // 2つの整数を加算する関数
    return a + b; // 結果を返す
}
int main() {
    int result = add(5, 3); // add関数を呼び出す
    cout << "合計: " << result << endl; // 結果を表示
    return 0;
}

合計: 8

クラスと関数の違い

クラスと関数は、プログラムの構造を形成するための異なる要素です。

以下の表に、主な違いを示します。

スクロールできます

特徴	クラス	関数
定義	データとメソッドをまとめたもの	特定の処理を実行するためのコードブロック
使用目的	オブジェクトの状態を管理する	処理の再利用や分割
インスタンス	オブジェクトを生成する	呼び出し時に実行される
継承	他のクラスから継承可能	継承の概念はない

クラスはデータとその操作を一体化し、関数は特定の処理を実行するための手段として、それぞれ異なる役割を果たします。

クラスを使うべきケース

データと操作を一体化したい場合

クラスを使用することで、データとそのデータに関連する操作を一つの単位としてまとめることができます。

これにより、データの整合性を保ちながら、関連するメソッドを同じ場所に集約できます。

例えば、銀行口座を表すクラスを考えてみましょう。

#include <iostream>
using namespace std;
class BankAccount {
private:
    double balance; // 残高
public:
    BankAccount(double initialBalance) { // コンストラクタ
        balance = initialBalance; // 初期残高を設定
    }
    void deposit(double amount) { // 入金メソッド
        balance += amount; // 残高を増加
    }
    void withdraw(double amount) { // 出金メソッド
        if (amount <= balance) {
            balance -= amount; // 残高を減少
        } else {
            cout << "残高不足です。" << endl;
        }
    }
    void displayBalance() { // 残高表示メソッド
        cout << "残高: " << balance << endl;
    }
};
int main() {
    BankAccount myAccount(1000.0); // 銀行口座のオブジェクトを生成
    myAccount.deposit(500.0); // 入金
    myAccount.withdraw(200.0); // 出金
    myAccount.displayBalance(); // 残高を表示
    return 0;
}

残高: 1300

複数の関連する操作をまとめたい場合

クラスを使うことで、複数の関連する操作を一つのクラスにまとめることができます。

これにより、コードの可読性が向上し、メンテナンスが容易になります。

例えば、図形を扱うクラスを考えてみましょう。

#include <cmath> // 数学関数を使用
#include <iostream>
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif

using namespace std;
class Circle {
   private:
    double radius; // 半径
   public:
    Circle(double r) : radius(r) {}    // コンストラクタ
    double area() {                    // 面積を計算するメソッド
        return M_PI * radius * radius; // πr²
    }
    double circumference() {      // 周囲の長さを計算するメソッド
        return 2 * M_PI * radius; // 2πr
    }
};
int main() {
    Circle myCircle(5.0); // Circleクラスのオブジェクトを生成
    cout << "面積: " << myCircle.area() << endl; // 面積を表示
    cout << "周囲の長さ: " << myCircle.circumference()
         << endl; // 周囲の長さを表示
    return 0;
}

面積: 78.5398
周囲の長さ: 31.4159

オブジェクトの状態を管理したい場合

クラスは、オブジェクトの状態を管理するために非常に有効です。

オブジェクトの属性をクラスのデータメンバーとして定義し、メソッドを通じてその状態を変更することができます。

例えば、ゲームキャラクターの状態を管理するクラスを考えてみましょう。

#include <iostream>
using namespace std;
class Character {
private:
    string name; // 名前
    int health;  // ヘルス
public:
    Character(string n, int h) : name(n), health(h) {} // コンストラクタ
    void takeDamage(int damage) { // ダメージを受けるメソッド
        health -= damage; // ヘルスを減少
        if (health < 0) health = 0; // ヘルスが0未満にならないようにする
    }
    void displayStatus() { // ステータスを表示するメソッド
        cout << "キャラクター: " << name << ", ヘルス: " << health << endl;
    }
};
int main() {
    Character hero("勇者", 100); // Characterクラスのオブジェクトを生成
    hero.takeDamage(30); // ダメージを受ける
    hero.displayStatus(); // ステータスを表示
    return 0;
}

キャラクター: 勇者, ヘルス: 70

継承やポリモーフィズムを利用したい場合

クラスを使用することで、継承やポリモーフィズムを利用することができます。

これにより、コードの再利用性が高まり、異なるクラス間での共通のインターフェースを持つことが可能になります。

以下は、動物を表すクラスの例です。

#include <iostream>
using namespace std;
class Animal { // 基底クラス
public:
    virtual void speak() { // 仮想関数
        cout << "動物の声" << endl;
    }
};
class Dog : public Animal { // 派生クラス
public:
    void speak() override { // オーバーライド
        cout << "ワンワン" << endl;
    }
};
class Cat : public Animal { // 派生クラス
public:
    void speak() override { // オーバーライド
        cout << "ニャー" << endl;
    }
};
int main() {
    Animal* myAnimal; // Animal型のポインタ
    Dog myDog; // Dogオブジェクト
    Cat myCat; // Catオブジェクト
    myAnimal = &myDog; // Dogオブジェクトを指す
    myAnimal->speak(); // "ワンワン"を出力
    myAnimal = &myCat; // Catオブジェクトを指す
    myAnimal->speak(); // "ニャー"を出力
    return 0;
}

ワンワン
ニャー

クラスを使用することで、データと操作を一体化し、関連する操作をまとめ、オブジェクトの状態を管理し、さらに継承やポリモーフィズムを利用することができます。

これにより、より効率的で柔軟なプログラムを構築することが可能になります。

関数を使うべきケース

単一の処理を行う場合

関数は、特定の処理を行うために設計されており、単一のタスクを実行するのに最適です。

例えば、数値の加算を行う関数を考えてみましょう。

#include <iostream>
using namespace std;
int add(int a, int b) { // 2つの整数を加算する関数
    return a + b; // 結果を返す
}
int main() {
    int result = add(10, 5); // add関数を呼び出す
    cout << "合計: " << result << endl; // 結果を表示
    return 0;
}

合計: 15

このように、関数は特定の処理を簡潔に表現するために使用されます。

データの状態を持たない場合

関数は、データの状態を持たず、引数を受け取って処理を行う場合に適しています。

例えば、文字列を逆にする関数を考えてみましょう。

#include <iostream>
#include <string>
using namespace std;
string reverseString(const string& str) { // 文字列を逆にする関数
    string reversed; // 逆にした文字列
    for (int i = str.length() - 1; i >= 0; i--) {
        reversed += str[i]; // 逆順に文字を追加
    }
    return reversed; // 逆にした文字列を返す
}
int main() {
    string original = "こんにちは"; // 元の文字列
    string reversed = reverseString(original); // 逆にする
    cout << "逆の文字列: " << reversed << endl; // 結果を表示
    return 0;
}

逆の文字列: はちにんこ

このように、関数はデータの状態を持たず、引数に基づいて処理を行う場合に適しています。

再利用性を高めたい場合

関数を使用することで、同じ処理を何度も書く必要がなくなり、コードの再利用性を高めることができます。

例えば、配列の最大値を求める関数を考えてみましょう。

#include <iostream>
using namespace std;
int findMax(int arr[], int size) { // 配列の最大値を求める関数
    int max = arr[0]; // 初期値として最初の要素を設定
    for (int i = 1; i < size; i++) {
        if (arr[i] > max) {
            max = arr[i]; // 最大値を更新
        }
    }
    return max; // 最大値を返す
}
int main() {
    int numbers[] = {3, 5, 7, 2, 8}; // 配列
    int maxNumber = findMax(numbers, 5); // 最大値を求める
    cout << "最大値: " << maxNumber << endl; // 結果を表示
    return 0;
}

最大値: 8

このように、関数を使うことで、同じ処理を何度でも再利用することができます。

グローバルな操作を行いたい場合

関数は、プログラム全体で共通の操作を行うために使用されることがあります。

例えば、プログラムの設定を表示する関数を考えてみましょう。

#include <iostream>
using namespace std;
void displaySettings() { // 設定を表示する関数
    cout << "アプリケーション設定:" << endl;
    cout << "バージョン: 1.0" << endl;
    cout << "言語: 日本語" << endl;
}
int main() {
    displaySettings(); // 設定を表示
    return 0;
}

アプリケーション設定:
バージョン: 1.0
言語: 日本語

このように、関数を使用することで、プログラム全体で共通の操作を簡潔に行うことができます。

関数は、特定の処理を行うための強力なツールであり、プログラムの構造を整理し、再利用性を高めるために非常に有効です。

クラスと関数の併用

クラス内で関数を定義する

クラス内で定義された関数は、メンバ関数と呼ばれ、クラスのオブジェクトに関連する操作を実行します。

メンバ関数は、クラスのデータメンバーにアクセスできるため、オブジェクトの状態を操作するのに便利です。

以下は、クラス内で関数を定義する例です。

#include <iostream>
using namespace std;
class Rectangle {
private:
    double width;  // 幅
    double height; // 高さ
public:
    Rectangle(double w, double h) : width(w), height(h) {} // コンストラクタ
    double area() { // 面積を計算するメンバ関数
        return width * height; // 幅 × 高さ
    }
};
int main() {
    Rectangle myRectangle(5.0, 3.0); // Rectangleクラスのオブジェクトを生成
    cout << "面積: " << myRectangle.area() << endl; // 面積を表示
    return 0;
}

面積: 15

メンバ関数と静的関数の違い

メンバ関数は、オブジェクトの状態に依存しているのに対し、静的関数はクラスに属するが、オブジェクトの状態に依存しない関数です。

静的関数は、クラス名を通じて呼び出すことができ、オブジェクトを生成せずに使用できます。

以下は、メンバ関数と静的関数の違いを示す例です。

#include <iostream>
using namespace std;
class MathUtils {
public:
    static int add(int a, int b) { // 静的関数
        return a + b; // 結果を返す
    }
    int multiply(int a, int b) { // メンバ関数
        return a * b; // 結果を返す
    }
};
int main() {
    cout << "加算: " << MathUtils::add(5, 3) << endl; // 静的関数を呼び出す
    MathUtils math; // MathUtilsクラスのオブジェクトを生成
    cout << "乗算: " << math.multiply(5, 3) << endl; // メンバ関数を呼び出す
    return 0;
}

加算: 8
乗算: 15

クラス外での関数の利用

クラス外で定義された関数は、クラスのオブジェクトを引数として受け取ることができます。

これにより、クラスの機能を拡張したり、クラスのオブジェクトに対して操作を行ったりすることができます。

以下は、クラス外で関数を利用する例です。

#include <iostream>
using namespace std;
class Circle {
private:
    double radius; // 半径
public:
    Circle(double r) : radius(r) {} // コンストラクタ
    double getRadius() { // 半径を取得するメンバ関数
        return radius; // 半径を返す
    }
};
double calculateCircumference(Circle& circle) { // クラス外で定義された関数
    return 2 * 3.14 * circle.getRadius(); // 周囲の長さを計算
}
int main() {
    Circle myCircle(5.0); // Circleクラスのオブジェクトを生成
    cout << "周囲の長さ: " << calculateCircumference(myCircle) << endl; // 周囲の長さを表示
    return 0;
}

周囲の長さ: 31.4000

ユーティリティ関数の役割

ユーティリティ関数は、特定のクラスに依存せず、一般的な操作を行うために使用される関数です。

これらの関数は、複数のクラスやモジュールで再利用されることが多く、コードの重複を減らすのに役立ちます。

以下は、ユーティリティ関数の例です。

#include <iostream>
using namespace std;
int max(int a, int b) { // 2つの整数の最大値を返すユーティリティ関数
    return (a > b) ? a : b; // 最大値を返す
}
int main() {
    int x = 10, y = 20;
    cout << "最大値: " << max(x, y) << endl; // 最大値を表示
    return 0;
}

最大値: 20

クラスと関数を併用することで、オブジェクト指向プログラミングの利点を活かしつつ、柔軟で再利用可能なコードを構築することができます。

メンバ関数や静的関数、クラス外での関数の利用、ユーティリティ関数の役割を理解することで、より効果的なプログラムを作成できるようになります。

クラスと関数の使い分けの具体例

数学的な計算を行う場合

数学的な計算を行う場合、クラスを使用して関連するデータと操作をまとめることができます。

例えば、ベクトルの計算を行うクラスを作成し、加算やスカラー倍などの操作をメンバ関数として定義することができます。

以下は、ベクトルのクラスの例です。

#include <iostream>
using namespace std;
class Vector {
private:
    double x, y; // ベクトルの成分
public:
    Vector(double xVal, double yVal) : x(xVal), y(yVal) {} // コンストラクタ
    Vector add(const Vector& other) { // ベクトルの加算
        return Vector(x + other.x, y + other.y); // 新しいベクトルを返す
    }
    void display() { // ベクトルを表示するメンバ関数
        cout << "ベクトル: (" << x << ", " << y << ")" << endl;
    }
};
int main() {
    Vector v1(3.0, 4.0); // ベクトルv1を生成
    Vector v2(1.0, 2.0); // ベクトルv2を生成
    Vector v3 = v1.add(v2); // ベクトルの加算
    v3.display(); // 結果を表示
    return 0;
}

ベクトル: (4, 6)

ゲーム開発におけるオブジェクト管理

ゲーム開発では、キャラクターやアイテムなどのオブジェクトを管理するためにクラスを使用します。

各オブジェクトの状態や動作をクラスで定義し、関数を使って操作を行います。

以下は、ゲームキャラクターのクラスの例です。

#include <iostream>
using namespace std;
class GameCharacter {
private:
    string name; // キャラクターの名前
    int health;  // ヘルス
public:
    GameCharacter(string n, int h) : name(n), health(h) {} // コンストラクタ
    void takeDamage(int damage) { // ダメージを受けるメソッド
        health -= damage; // ヘルスを減少
        if (health < 0) health = 0; // ヘルスが0未満にならないようにする
    }
    void displayStatus() { // ステータスを表示するメソッド
        cout << "キャラクター: " << name << ", ヘルス: " << health << endl;
    }
};
int main() {
    GameCharacter hero("勇者", 100); // キャラクターを生成
    hero.takeDamage(30); // ダメージを受ける
    hero.displayStatus(); // ステータスを表示
    return 0;
}

キャラクター: 勇者, ヘルス: 70

データベース操作のラッピング

データベース操作を行う場合、クラスを使用してデータベース接続やクエリの実行を管理することができます。

関数を使って、特定の操作を実行することができます。

以下は、データベース操作をラッピングするクラスの例です。

#include <iostream>
#include <string>
using namespace std;
class Database {
public:
    void connect() { // データベースに接続するメソッド
        cout << "データベースに接続しました。" << endl;
    }
    void executeQuery(const string& query) { // クエリを実行するメソッド
        cout << "クエリを実行: " << query << endl;
    }
};
int main() {
    Database db; // Databaseクラスのオブジェクトを生成
    db.connect(); // データベースに接続
    db.executeQuery("SELECT * FROM users;"); // クエリを実行
    return 0;
}

データベースに接続しました。
クエリを実行: SELECT * FROM users;

ファイル操作の抽象化

ファイル操作を行う場合、クラスを使用してファイルの読み書きを管理することができます。

関数を使って、特定のファイル操作を実行することができます。

以下は、ファイル操作を抽象化するクラスの例です。

#include <iostream>
#include <fstream>
#include <string>
using namespace std;
class FileManager {
private:
    string filename; // ファイル名
public:
    FileManager(const string& name) : filename(name) {} // コンストラクタ
    void writeToFile(const string& content) { // ファイルに書き込むメソッド
        ofstream outFile(filename); // 出力ファイルストリームを開く
        if (outFile.is_open()) {
            outFile << content; // 内容を書き込む
            outFile.close(); // ファイルを閉じる
        } else {
            cout << "ファイルを開けませんでした。" << endl;
        }
    }
    void readFromFile() { // ファイルから読み込むメソッド
        ifstream inFile(filename); // 入力ファイルストリームを開く
        string line;
        if (inFile.is_open()) {
            while (getline(inFile, line)) {
                cout << line << endl; // 内容を表示
            }
            inFile.close(); // ファイルを閉じる
        } else {
            cout << "ファイルを開けませんでした。" << endl;
        }
    }
};
int main() {
    FileManager file("example.txt"); // FileManagerクラスのオブジェクトを生成
    file.writeToFile("こんにちは、世界！"); // ファイルに書き込む
    file.readFromFile(); // ファイルから読み込む
    return 0;
}

こんにちは、世界！

クラスと関数を使い分けることで、特定のタスクに応じた柔軟で効率的なプログラムを構築することができます。

数学的な計算、ゲーム開発、データベース操作、ファイル操作など、さまざまな場面でその利点を活かすことができます。

応用例

デザインパターンにおけるクラスと関数の使い分け

デザインパターンは、ソフトウェア設計における一般的な問題を解決するための再利用可能なソリューションです。

クラスと関数の使い分けは、デザインパターンの実装において重要な役割を果たします。

例えば、シングルトンパターンでは、クラスのインスタンスを一つだけに制限し、そのインスタンスにアクセスするための静的関数を提供します。

以下は、シングルトンパターンの例です。

#include <iostream>
using namespace std;
class Singleton {
private:
    static Singleton* instance; // インスタンスのポインタ
    // コンストラクタをプライベートにする
    Singleton() {}
public:
    static Singleton* getInstance() { // インスタンスを取得する静的関数
        if (instance == nullptr) {
            instance = new Singleton(); // 新しいインスタンスを生成
        }
        return instance; // インスタンスを返す
    }
};
Singleton* Singleton::instance = nullptr; // インスタンスの初期化
int main() {
    Singleton* s1 = Singleton::getInstance(); // インスタンスを取得
    Singleton* s2 = Singleton::getInstance(); // 同じインスタンスを取得
    cout << (s1 == s2) << endl; // 同じインスタンスであることを確認
    return 0;
}

テンプレートメタプログラミングでの使い分け

テンプレートメタプログラミングは、コンパイル時に型に基づいてコードを生成する技術です。

クラスと関数のテンプレートを使い分けることで、柔軟で再利用可能なコードを作成できます。

以下は、テンプレートを使用した関数の例です。

#include <iostream>
using namespace std;
template <typename T>
T add(T a, T b) { // テンプレート関数
    return a + b; // 加算結果を返す
}
int main() {
    cout << "整数の加算: " << add(5, 3) << endl; // 整数の加算
    cout << "浮動小数点数の加算: " << add(5.5, 3.2) << endl; // 浮動小数点数の加算
    return 0;
}

整数の加算: 8
浮動小数点数の加算: 8.7

ラムダ式とクラスの併用

ラムダ式は、無名関数を定義するための便利な方法で、クラスと併用することで、特定の操作を簡潔に記述できます。

例えば、クラス内でラムダ式を使用して、データのフィルタリングを行うことができます。

以下は、ラムダ式を使用した例です。

#include <iostream>
#include <vector>
#include <algorithm> // std::remove_if
using namespace std;
class NumberFilter {
public:
    void filter(vector<int>& numbers) { // フィルタリングメソッド
        numbers.erase(remove_if(numbers.begin(), numbers.end(), [](int n) { // ラムダ式
            return n % 2 == 0; // 偶数を削除
        }), numbers.end());
    }
};
int main() {
    vector<int> numbers = {1, 2, 3, 4, 5, 6}; // 数字のベクター
    NumberFilter filter; // NumberFilterクラスのオブジェクトを生成
    filter.filter(numbers); // フィルタリングを実行
    for (int n : numbers) {
        cout << n << " "; // 結果を表示
    }
    cout << endl;
    return 0;
}

1 3 5

関数オブジェクト(ファンクタ)の活用

関数オブジェクト(ファンクタ)は、関数のように振る舞うオブジェクトで、クラス内にoperator()を定義することで実現できます。

これにより、関数のようにオブジェクトを使用することができます。

以下は、関数オブジェクトの例です。

#include <iostream>
using namespace std;
class Adder {
private:
    int value; // 加算する値
public:
    Adder(int v) : value(v) {} // コンストラクタ
    int operator()(int x) { // 関数オブジェクト
        return x + value; // 加算結果を返す
    }
};
int main() {
    Adder addFive(5); // Adderオブジェクトを生成
    cout << "3 + 5 = " << addFive(3) << endl; // 関数オブジェクトを使用
    return 0;
}

3 + 5 = 8

クラスと関数のパフォーマンス比較

クラスと関数のパフォーマンスは、使用する状況によって異なります。

クラスはオブジェクトの状態を管理するために便利ですが、オーバーヘッドが発生することがあります。

一方、関数は軽量で、特定の処理を迅速に実行できます。

以下は、クラスと関数のパフォーマンスを比較する簡単な例です。

#include <iostream>
#include <chrono> // 時間計測
using namespace std;
class Timer {
public:
    void start() {
        startTime = chrono::high_resolution_clock::now(); // 開始時間を記録
    }
    double stop() {
        auto endTime = chrono::high_resolution_clock::now(); // 終了時間を記録
        return chrono::duration<double>(endTime - startTime).count(); // 経過時間を返す
    }
private:
    chrono::high_resolution_clock::time_point startTime; // 開始時間
};
void simpleFunction() { // 単純な関数
    for (int i = 0; i < 1000000; i++); // 処理
}
int main() {
    Timer timer; // Timerクラスのオブジェクトを生成
    timer.start(); // タイマーを開始
    simpleFunction(); // 関数を実行
    double elapsed = timer.stop(); // 経過時間を計測
    cout << "関数の実行時間: " << elapsed << "秒" << endl;
    return 0;
}

関数の実行時間: 0.012345秒

クラスと関数の使い分けは、プログラムの設計やパフォーマンスに大きな影響を与えます。

デザインパターン、テンプレートメタプログラミング、ラムダ式、関数オブジェクトなど、さまざまな応用例を通じて、効果的なプログラムを構築するための知識を深めることができます。

よくある質問

クラスと関数のどちらを優先すべき？

クラスと関数のどちらを優先すべきかは、プログラムの目的や設計によります。

オブジェクト指向のアプローチが必要な場合や、データとその操作を一体化したい場合はクラスを使用することが適しています。

一方、単純な処理や特定のタスクを実行する場合は、関数を使用する方がシンプルで効率的です。

以下のポイントを考慮すると良いでしょう。

クラスを優先する場合:
- データの状態を管理したいとき
- 複数の関連する操作をまとめたいとき
- 継承やポリモーフィズムを利用したいとき
関数を優先する場合:
- 単一の処理を行うとき
- データの状態を持たないとき
- 再利用性を高めたいとき

関数内でクラスを定義することは可能？

はい、関数内でクラスを定義することは可能です。

このようなクラスは、ローカルクラスと呼ばれ、関数のスコープ内でのみ有効です。

ローカルクラスは、関数内で特定の処理を行うために使用されることが多く、外部からアクセスすることはできません。

以下は、関数内でクラスを定義する例です。

#include <iostream>
using namespace std;
void myFunction() {
    class LocalClass { // ローカルクラスの定義
    public:
        void display() {
            cout << "ローカルクラスのメソッドです。" << endl;
        }
    };
    LocalClass localObj; // ローカルクラスのオブジェクトを生成
    localObj.display(); // メソッドを呼び出す
}
int main() {
    myFunction(); // 関数を呼び出す
    return 0;
}

ローカルクラスのメソッドです。

クラスを使わずに関数だけでプログラムを構築できる？

はい、クラスを使わずに関数だけでプログラムを構築することは可能です。

特に、プログラムが単純で、データの状態を管理する必要がない場合は、関数だけで十分です。

関数を使って、必要な処理を実行し、データを引数として渡すことで、プログラムを構築できます。

以下は、関数だけで構成された簡単なプログラムの例です。

#include <iostream>
using namespace std;
void greet(const string& name) { // 名前を受け取る関数
    cout << "こんにちは、" << name << "さん！" << endl; // 挨拶を表示
}
int main() {
    greet("太郎"); // 関数を呼び出す
    return 0;
}