【C++】第一回 C++を使ったゲーム開発 〜C++基礎知識(型、ポインタ、メモリ管理)編〜

// 整数型
// *unsignedを付けると正の範囲だけとなる
// *ビット演算、添え字、不変な数値等に使用する
int num1;            // -2,147,483,648 ～ 2,147,483,647
unsigned int num2;   // 0 ～ 4,294,967,295

// 浮動小数点型
float num3;  // 3.4E +/- 38 (7 桁)
double num4; // 1.7E +/- 308 (15 桁)

// 文字を表す整数型
// *文字として扱う場合はchar
// *1バイト幅であるのが強み
// *ビット演算や数値として扱う場合はunsigned
char c1;          // -128 ~ 127
unsigned char c2; // 0 ～ 255

// 文字列
// *stringはC++標準ライブラリ
// *可変な場合はstringを使った方が楽
char str1[] = "テスト";
std::string str2 = "テスト";

// フラグ
bool flag; // true or false

    // aの参照を代入
    int a = 10;
    int& b = a;
    std::cout << a << std::endl; // 10
    std::cout << b << std::endl; // 10

    // aを変えるとbも変わる
    a = 20;
    std::cout << a << std::endl; // 20
    std::cout << b << std::endl; // 20

    // 変数aのアドレスをポインタに設定
    // &を付けるとアドレスを返す
    int a = 10;
    int* p = &a;
    std::cout << p << std::endl;  // アドレスが出力される(0x7ffee93d07ccなど)
    std::cout << *p << std::endl; // 10

    // *をつけると値にアクセスできる
    *p = 20;
    std::cout << *p << std::endl; // 20

    // ポインタの初期化はnullptr(何も指し示さない状態)
    p = nullptr;

    // 配列を作成
    int a[5];
    a[0] = 10;
    a[1] = 20;
    a[2] = 30;

    // 配列[0]のアドレスをポインタに設定
    int* p = &a[0];
    std::cout << *p << std::endl; // 10

    // インクリメントで次のアドレスを参照できる
    // 配列の場合、連続したアドレスを確保しているため
    // [0] -> [1] -> [2] ... となる
    ++p;
    std::cout << *p << std::endl; // 20
    ++p;
    std::cout << *p << std::endl; // 30

// スワップ関数(NG)
// 値渡しのため元の変数が変わらない
void SwapNG(int a, int b)
{
    int temp = a;
    a = b;
    b = temp;
}

// スワップ関数
// (参照で渡した例)
void Swap1(int& a, int& b)
{
    int temp = a;
    a = b;
    b = temp;
}

// スワップ関数
// (ポインタで渡した例)
void Swap2(int* a, int* b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

int main() {

    int a = 10;
    int b = 20;
    // 参照で渡した場合
    Swap1(a, b);
    // ポインタで渡した場合
    // &が付くため値が変わることが予測しやすい
    Swap2(&a, &b);

    return 0;
}

// メッセージ出力
// *オブジェクトはコピーが発生しない参照orポインタ渡しの方が効率がよい
// *書き換えを行わない場合はconstを付けることで不変であることを保証できる
void PrintMessage(const std::string& message)
{
    std::cout << message << std::endl;
}

int main() {
    PrintMessage("こんにゃく"); // 呼び出し側も変わらないと思っている
    return 0;
}

    // メモリの静的確保
    // *コンパイル時にスタック領域にメモリが確保される
    // *スコープを抜けると破棄される
    int num1 = 10;
    int num1_array[] = {10, 20, 30};

    // メモリの動的確保(new/delete)
    // *プログラム実行中にヒープ領域にメモリが確保される
    // *確保したメモリのアドレスをポインタとして受け取る
    // *自身でメモリ破棄のタイミングを指定できる
    int* num2 = new int(10);
    int* num2_array = new int[3];
    num2_array[0] = 10;
    num2_array[1] = 20;
    num2_array[2] = 30;
    // 自身でメモリを破棄する
    delete num2;
    delete[] num2_array; // []を付けること！

#pragma once

// エレキベアクラス
class ElekiBear {
public:
    ElekiBear(int hp, char* name = "エレキベア", bool is_dead = false); // デフォルト値も指定可
    ~ElekiBear();
    const char* GetVoice();
    void Say();
private:
    int m_hp;
    char* m_name;
    bool m_is_dead;
};

#include <iostream>
#include "ElekiBear.h"

// コンストラクタ
ElekiBear::ElekiBear(int hp, char* name, bool is_dead) :
m_hp(hp),
m_name(nullptr),
m_is_dead(is_dead)
{
    m_name = new char[strlen(name) + 1];
    strcpy(m_name, name);
}

// デストラクタ
ElekiBear::~ElekiBear()
{
    delete[] m_name; // 動的なオブジェクトは破棄する
}

// 鳴き声を返す
const char* ElekiBear::GetVoice()
{
    return "クマ〜〜〜";
}

// 喋らせる
void ElekiBear::Say()
{
    std::cout << m_name << "：" << GetVoice() << std::endl;
}

#include <iostream>
#include "ElekiBear.h"

int main() {
    // エレキベアインスタンス生成
    ElekiBear* bear = new ElekiBear(100);
    bear->Say(); // エレキベア：クマ〜〜〜
    // 削除も忘れずに！
    delete bear;

    return 0;
}

#pragma once

// モンスター基底クラス
class Monster {
public:
    Monster(int hp, char* name = "NONAME", bool is_dead = false);
    virtual ~Monster();
    virtual const char* GetVoice();
    void Say();
private:
    int m_hp;
    char* m_name;
    bool m_is_dead;
};

#include <iostream>
#include "Monster.h"

// コンストラクタ
Monster::Monster(int hp, char* name, bool is_dead) :
m_hp(hp),
m_name(nullptr),
m_is_dead(is_dead)
{
    m_name = new char[strlen(name) + 1];
    strcpy(m_name, name);
}

// デストラクタ
Monster::~Monster()
{
    delete[] m_name; // 動的なオブジェクトは破棄する
}

const char *Monster::GetVoice()
{
    return "";
}

// 喋らせる
void Monster::Say()
{
    std::cout << m_name << "：" << GetVoice() << std::endl;
}

#pragma once
#include "Monster.h"

// エレキベアクラス
// (Monsterクラスを継承)
class ElekiBear : public Monster {
public:
    ElekiBear(int hp, char* name = "エレキベア", bool is_dead = false);
    ~ElekiBear();
    const char* GetVoice() override;
};

#include "ElekiBear.h"

// コンストラクタ
// 親クラスのコンストラクタを指定
ElekiBear::ElekiBear(int hp, char* name, bool is_dead) :
Monster(hp, name, is_dead)
{
}

// デストラクタ
// 親クラスのデストラクタも呼ばれる
ElekiBear::~ElekiBear()
{
}

// GetVoiceメソッドをオーバーライド
// 鳴き声を返す
const char* ElekiBear::GetVoice()
{
    return "クマ〜〜〜";
}

#pragma once
#include "Monster.h"

// ゴロヤンクラス
// (Monsterクラスを継承)
class Goroyan : public Monster {
public:
    Goroyan(int hp, char* name = "ゴロヤン", bool is_dead = false);
    ~Goroyan();
    const char* GetVoice() override;
};

#include "Goroyan.h"

// コンストラクタ
// 親クラスのコンストラクタを指定
Goroyan::Goroyan(int hp, char* name, bool is_dead) :
Monster(hp, name, is_dead)
{
}

// デストラクタ
// 親クラスのデストラクタも呼ばれる
Goroyan::~Goroyan()
{
}

// GetVoiceメソッドをオーバーライド
// 鳴き声を返す
const char* Goroyan::GetVoice()
{
    return "ゴロ〜〜〜";
}

#include <iostream>
#include "ElekiBear.h"
#include "Goroyan.h"

int main() {

    ElekiBear* bear = new ElekiBear(100);
    bear->Say(); // エレキベア：クマ〜〜〜
    delete bear;

    Goroyan* goroyan = new Goroyan(300);
    goroyan->Say(); // ゴロヤン：ゴロ〜〜〜
    delete goroyan;

    return 0;
}

#pragma once

// エレキベアクラス
class ElekiBear {
public:
    ElekiBear(int hp, char* name = "エレキベア", bool is_dead = false); // デフォルト値も指定可
    ~ElekiBear();
    const char* GetVoice();
    void Say();
private:
    int m_hp;
    char* m_name;
    bool m_is_dead;
};

#ifndef CPPSTANDARD_ELEKIBEAR_H
#define CPPSTANDARD_ELEKIBEAR_H

class ElekiBear {
public:
    ElekiBear(int hp, char* name = "エレキベア", bool is_dead = false); // デフォルト値も指定可
    ~ElekiBear();
    const char* GetVoice();
    void Say();
private:
    int m_hp;
    char* m_name;
    bool m_is_dead;
};

#endif //CPPSTANDARD_ELEKIBEAR_H

#pragma once

// 2次元ベクトルクラス
class Vector2 {
public:
    float x;
    float y;

    Vector2();
    explicit Vector2(float inX, float inY);

    void operator*=(float scalar);
    void operator+=(const Vector2& a);
    void operator-=(const Vector2& a);
};

#include "Vector2.h"

Vector2::Vector2()
:x(0.0f)
,y(0.0f)
{}

Vector2::Vector2(float inX, float inY)
:x(inX)
,y(inY)
{}

// Scalar *=
void Vector2::operator*=(float scalar)
{
    x *= scalar;
    y *= scalar;
}

// Vector +=
void Vector2::operator+=(const Vector2& a)
{
    x += a.x;
    y += a.y;
}

// Vector -=
void Vector2::operator-=(const Vector2& a)
{
    x -= a.x;
    y -= a.y;
}

#include <iostream>
#include "Vector2.h"

int main() {

    // ベクトル定義
    Vector2 vec1(2.0f, 3.0f);
    Vector2 vec2(3.0f, 2.0f);
    std::cout << vec1.x << ", " << vec1.y << std::endl; // 2, 3
    // ベクトルを加算
    vec1 += vec2;
    std::cout << vec1.x << ", " << vec1.y << std::endl; // 5, 5

    return 0;
}