C++の型一覧｜基本データ型から最新の型推論・キャストまで解説

#include <iostream>

int main() {
    // 整数型の宣言
    int age = 25;
    unsigned int distance = 1000u;
    long long large_value = 123456789012345LL;

    // 浮動小数点型の宣言
    float weight = 65.5f;
    double pi = 3.141592653589793;

    // 真偽値
    bool is_active = true;

    // 文字型
    char grade = 'A';

    std::cout << "Age: " << age << ", Pi: " << pi << ", Active: " << is_active << std::endl;

    return 0;
}

int numbers[5] = {1, 2, 3, 4, 5}; // Cスタイル配列

int value = 10;
int* ptr = &value; // valueのアドレスを指すポインタ
std::cout << *ptr << std::endl; // 間接参照して値(10)を表示

int x = 10;
int& ref = x;  // xに「ref」という別名を付ける
ref = 20;      // refを書き換えると、元のxも20になる
std::cout << x; // 実行結果: 20

int&& rref = 10 + 20; // 計算結果などの「一時的な値」を保持できる
rref += 5;            // その値をそのまま再利用（ムーブ）できる
std::cout << rref;    // 実行結果: 35

#include <iostream>

class BankAccount {
    // ここはデフォルトで private になるため、外から「balance」は触れない
    double balance;

public:
    // コンストラクタ（初期化）
    BankAccount(double initial_balance) {
        balance = initial_balance;
    }

    // 預金する関数（ルールに基づいた操作）
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
            std::cout << amount << "円入金しました。" << std::endl;
        }
    }

    void showBalance() {
        std::cout << "現在の残高: " << balance << "円" << std::endl;
    }
};

int main() {
    BankAccount myAccount(1000);

    // myAccount.balance = 1000000; // エラー！直接書き換えはできない（安全）
    myAccount.deposit(500);         // 公開されている関数を通して操作する
    myAccount.showBalance();

    return 0;
}

太郎さんは20歳です。
500円入金しました。
現在の残高: 1500円

// スコープ付き列挙型（推奨）
enum class Color {
    Red,
    Green,
    Blue
};

Color myColor = Color::Red;

#include <iostream>
#include <string>

// 引数に const を付けると、関数の中で引数を書き換えられなくなる
void printMessage(const std::string& msg) {
    // msg = "Changed"; // ここで書き換えようとするとコンパイルエラーになる
    std::cout << msg << std::endl;
}

int main() {
    // 1. 変数に const を付ける
    const double PI = 3.14159;
    
    // PI = 3.14; // コンパイルエラー：書き換え不可！

    std::cout << "円周率: " << PI << std::endl;

    // 2. 関数に渡す
    std::string text = "Hello Const";
    printMessage(text);

    return 0;
}

円周率: 3.14159
Hello Const

#include <iostream>

int main() {
    // volatile がないと、コンパイラは「この変数は中で変わってないから、
    // 何度もメモリを見に行く必要はないな」と判断（最適化）してしまうことがある
    volatile bool isReady = false; 

    std::cout << "準備を待っています..." << std::endl;

    // 本来は別のハードウェアや割り込み処理によって isReady が true に書き換わる
    // volatile があれば、毎回必ず「本当の今の値」をメモリまで見に行く
    while (!isReady) {
        // 実際にはここで外部からの変化を待つ
        break; // サンプルを終わらせるための記述
    }

    std::cout << "準備完了！" << std::endl;
    return 0;
}

準備を待っています...
準備完了！

auto x = 10; // xはint型
auto pi = 3.14; // piはdouble型

std::vector<int> vec = {1, 2, 3};
for (auto it = vec.begin(); it != vec.end(); ++it) {
    // 複雑な型名を省略できる
}

int a = 5;
decltype(a) b = 10; // bはaと同じint型

int g_value = 42;

int& getRef() { return g_value; } // 参照を返す関数

int main() {
    auto a = getRef();         // autoは参照を消すため、int型（コピー）になる
    decltype(auto) b = getRef(); // 参照を維持するため、int&型になる

    b = 100; // bを書き換えるとg_valueも変わるが、aを変えても変わらない
    return 0;
}

#include <iostream>
#include <string>
#include <string_view>

// string_viewを使うと、コピーなしで文字列を受け取れる
void printSimple(std::string_view sv) {
    std::cout << "表示: " << sv << " (長さ: " << sv.length() << ")" << std::endl;
}

int main() {
    std::string full_text = "C++ is powerful and fast.";

    // 文字列の「一部」をコピーせずに参照する
    // 7番目の文字から、8文字分だけを表示
    std::string_view sub = std::string_view(full_text).substr(7, 8);

    printSimple(full_text); // 全体を表示
    printSimple(sub);       // 部分文字列を表示

    return 0;
}

#include <optional>
#include <string>

std::optional<std::string> get_name(int id) {
    if (id == 1) return "Alice";
    return std::nullopt; // 値がないことを示す
}

#include <iostream>
#include <variant>
#include <any>
#include <string>

int main() {
    // --- std::variant (型安全な共用体) ---
    // intかstringのどちらか一つを保持できる
    std::variant<int, std::string> v = 10;
    std::cout << "variantの値: " << std::get<int>(v) << std::endl;

    v = "Hello"; // 途中で型を変えてもOK
    std::cout << "variantの値: " << std::get<std::string>(v) << std::endl;

    // --- std::any (任意の型) ---
    std::any a = 3.14; // doubleを入れる
    std::cout << "anyの値: " << std::any_cast<double>(a) << std::endl;

    a = true; // boolを入れ直す
    if (std::any_cast<bool>(a)) {
        std::cout << "anyの中身は true です" << std::endl;
    }

    return 0;
}

variantの値: 10
variantの値: Hello
anyの値: 3.14
anyの中身は true です

#include <iostream>
#include <vector>
#include <span>

// std::span を使うと、配列でもvectorでも同じように受け取れる
void printData(std::span<int> data) {
    std::cout << "データ一覧: ";
    for (int x : data) {
        std::cout << x << " ";
    }
    std::cout << "(要素数: " << data.size() << ")" << std::endl;
}

int main() {
    int arr[] = {1, 2, 3};           // C言語スタイルの配列
    std::vector<int> vec = {10, 20, 30, 40}; // vector

    printData(arr); // 配列を渡す
    printData(vec); // vectorを渡す

    // vectorの「真ん中の2つだけ」を切り出して渡す（コピーは起きない）
    std::span<int> sub_span = std::span(vec).subspan(1, 2);
    std::cout << "部分的な";
    printData(sub_span);

    return 0;
}

データ一覧: 1 2 3 (要素数: 3)
データ一覧: 10 20 30 40 (要素数: 4)
部分的なデータ一覧: 20 30 (要素数: 2)

#include <iostream>

int main() {
    double pi = 3.14159;

    // double型からint型へ変換（小数点以下が切り捨てられる）
    int i = static_cast<int>(pi);

    std::cout << "元の値: " << pi << std::endl;
    std::cout << "変換後: " << i << std::endl;

    return 0;
}

元の値: 3.14159
変換後: 3

#include <iostream>

class Animal { public: virtual ~Animal() {} }; // 親クラス
class Dog : public Animal { public: void bark() { std::cout << "ワン！" << std::endl; } }; // 子クラス
class Cat : public Animal { }; // 別の子クラス

int main() {
    Animal* a = new Dog(); // 中身はDog

    // AnimalポインタをDogポインタに変換してみる
    Dog* d = dynamic_cast<Dog*>(a);

    if (d) {
        std::cout << "変換成功：";
        d->bark();
    } else {
        std::cout << "変換失敗" << std::endl;
    }

    delete a;
    return 0;
}

変換成功：ワン！

#include <iostream>

void printMessage(char* str) { // constがついていない古い関数を想定
    std::cout << str << std::endl;
}

int main() {
    const char* text = "Hello World";

    // printMessageはchar*を要求するが、textはconst char*なのでエラーになる
    // そこで const_cast で const を取り除く
    printMessage(const_cast<char*>(text));

    return 0;
}

Hello World

#include <iostream>

int main() {
    int n = 65;
    int* ptr = &n;

    // ポインタ（メモリ番地）を数値(long long型)として読み替える
    long long address = reinterpret_cast<long long>(ptr);

    std::cout << "変数の値: " << n << std::endl;
    std::cout << "変数のメモリ番地: " << address << std::endl;

    return 0;
}

変数の値: 65
変数のメモリ番地: 140726831336100 (※実行のたびに変わります)

#include <iostream>

class Base { virtual void dummy() {} };
class Derived : public Base {};

int main() {
    double d = 3.9;
    
    // static_cast: 数値変換
    int i = static_cast<int>(d); // i = 3
    
    Base* base_ptr = new Derived();
    // dynamic_cast: 実行時型チェック付き変換
    Derived* der_ptr = dynamic_cast<Derived*>(base_ptr);
    
    if (der_ptr) {
        std::cout << "Successfully cast to Derived" << std::endl;
    }

    delete base_ptr;
    return 0;
}

template <typename T>
concept Numeric = std::is_arithmetic_v<T>;

template <Numeric T>
T add(T a, T b) {
    return a + b;
}

#include <iostream>
#include <expected> // C++23から必要
#include <string>

// 割り算を行う関数
// 成功なら double を、失敗（0除算）なら string のエラーメッセージを返す
std::expected<double, std::string> divide(double a, double b) {
    if (b == 0.0) {
        // エラーのときは std::unexpected で包んで返す
        return std::unexpected("0で割ることはできません");
    }
    return a / b; // 成功ならそのまま値を返す
}

int main() {
    auto result = divide(10.0, 0.0);

    if (result) {
        // result が true なら成功（値が入っている）
        std::cout << "結果: " << result.value() << std::endl;
    } else {
        // result が false なら失敗（エラーが入っている）
        std::cout << "エラー発生: " << result.error() << std::endl;
    }

    return 0;
}

エラー発生: 0で割ることはできません