Category: C++

拡張クラスが既存のクラスのメンバを受け継ぐことを継承(inheritance)と呼ぶ
基本クラス、新しいクラスは派生クラスと呼ぶ

### 継承

class Car {
    private:
        int num;
        double gas;
    public:
        Car();
        void setCar(int n, double g);
        void show();
};

class RacingCar : public Car {
    private:
        int course;
    public:
        RacingCar();
        void setCourse(int c);
};

Car::Car() {
    num = 0;
    gas = 0.0;
    cout << "車を作成しました。\n";
}

void Car::setCar(int n, double g){
    num = n;
    gas = g;
    cout << "車のナンバーを" << num << "ガソリン量を" << gas << "にしました。\n";
}

void Car::show(){

    cout << "車のナンバーは" << num << "です。\n";
    cout << "ガソリン量は" << gas << "です。\n";
}

RacingCar::RacingCar(){
    course = 0;
    cout << "レーシングカーを作成しました。\n";
}

void RacingCar::setCourse(int c){
    course = c;
    cout << "コース番号を" << course << "にしました。\n";
}

int main() {
    
    RacingCar rccar1;

    rccar1.setCar(1234, 20.5);
    rccar1.setCourse(5);
    
    return 0;
}

$ g++ -o sample sample.cpp && ./sample
車を作成しました。
レーシングカードを作成しました。
車のナンバーを1234ガソリン量を20.5にしました。
コース番号を5にしました。

### 基本クラスのコンストラクタを指定
RacingCar::RacingCar(int n, double g, int c): Car(n, g) が呼び出されるようになる。

class Car {
    private:
        int num;
        double gas;
    public:
        Car();
        Car(int n, double g);
        void setCar(int n, double g);
        void show();
};

class RacingCar : public Car {
    private:
        int course;
    public:
        RacingCar();
        RacingCar(int n, double g, int c);
        void setCourse(int c);
};

Car::Car() {
    num = 0;
    gas = 0.0;
    cout << "車を作成しました。\n";
}

Car::Car(int n, double g){
    num = n;
    gas = g;
    cout << "ナンバー" << num << "ガソリン量" << gas << "の車を作成しました。\n";
}

void Car::setCar(int n, double g){
    num = n;
    gas = g;
    cout << "車のナンバーを" << num << "ガソリン量を" << gas << "にしました。\n";
}

void Car::show(){

    cout << "車のナンバーは" << num << "です。\n";
    cout << "ガソリン量は" << gas << "です。\n";
}

RacingCar::RacingCar(){
    course = 0;
    cout << "レーシングカーを作成しました。\n";
}

RacingCar::RacingCar(int n, double g, int c): Car(n, g){
    course = 0;
    cout << "コース番号" << course << "のレーシングカーを作成しました。\n";
}

void RacingCar::setCourse(int c){
    course = c;
    cout << "コース番号を" << course << "にしました。\n";
}

int main() {
    
    RacingCar rccar1(1234, 20.5, 5);
    
    return 0;
}

constructorは戻り値を持たない
constractorは className::className(引数)となる

class Car {
    private:
        int num;
        double gas;
    public:
        Car();
        void show();
};

Car::Car() {
    num = 0;
    gas = 0.0;
    cout << "車を作成しました。\n";
}

void Car::show(){

    cout << "車のナンバーは" << num << "です。\n";
    cout << "ガソリン量は" << gas << "です。\n";
}

int main() {
    
    Car car1;

    car1.show();
    
    return 0;
}

引数の数・型が異なっていれば、同じ名前の関数を複数定義できる。これをオーバーっロードという。

class Car {
    private:
        int num;
        double gas;
    public:
        Car();
        Car(int n, double g);
        void show();
};

Car::Car() {
    num = 0;
    gas = 0.0;
    cout << "車を作成しました。\n";
}

Car::Car(int n, double g){
    num = n;
    gas = g;
    cout << "車のナンバーは" << num << "ガソリン量は" << gas << "の車を作成しました。\n";
}


void Car::show(){

    cout << "車のナンバーは" << num << "です。\n";
    cout << "ガソリン量は" << gas << "です。\n";
}

int main() {
    
    Car car1;
    Car car2(1234, 20.5);
    
    return 0;
}

$ g++ -o sample sample.cpp && ./sample
車を作成しました。
車のナンバーは1234ガソリン量は20.5の車を作成しました。

### コンストラクタの応用
オブジェクtの配列を作成

int main() {
    
    Car mycars[3] = {
        Car(),
        Car(1234, 25.5),
        Car(4567, 52.2)
    };
    
    return 0;
}

$ g++ -o sample sample.cpp && ./sample
車を作成しました。
車のナンバーは1234ガソリン量は25.5の車を作成しました。
車のナンバーは4567ガソリン量は52.2の車を作成しました。

int main() {
    
    Car cars[3];
    
    return 0;
}

$ g++ -o sample sample.cpp && ./sample
車を作成しました。
車を作成しました。
車を作成しました。

class Car {
    private:
        int num;
        double gas;
    public:
        Car(int n=0, double g=0);
        void show();
};
//
int main() {
    
    Car car1;
    Car car2(1234, 20.5);
    
    return 0;
}

オブジェクトに関連づけられないメンバを静的メンバという
関数の前にstaticを付与する

class Car {
    private:
        int num;
        double gas;
    public:
        static int sum;
        Car();
        void setCar(int n, double g);
        void show();
        static void showSum();
};

Car::Car() {
    num = 0;
    gas = 0.0;
    sum++;
    cout << "車を作成しました。\n";
}

void Car::setCar(int n, double g){
    num = n;
    gas = g;
    cout << "車のナンバーは" << num << "ガソリン量は" << gas << "の車を作成しました。\n";
}

void Car::showSum(){
    cout << "車は全部で" << sum << "台あります。\n";
}

void Car::show(){

    cout << "車のナンバーは" << num << "です。\n";
    cout << "ガソリン量は" << gas << "です。\n";
}

int Car::sum = 0;

int main() {
    
    Car::showSum();

    Car car1;
    car1.setCar(1234, 20.5);

    Car::showSum();

    Car car2;
    car2.setCar(4567, 30.5);

    Car::showSum();
    
    return 0;
}

クラスの宣言
class className {
アクセス指定子:
変数の宣言;
関数の宣言
}

メンバ関数の定義
戻り値の型　クラス名::メンバ関数名(引数リスト){
}

「::」はscope resolution operatorという

class Car {
    public:
        int num;
        double gas;
        void show();
};

void Car::show(){

    cout << "車のナンバーは" << num << "です。\n";
    cout << "ガソリン量は" << gas << "です。\n";
}

int main() {
    
    Car car1;

    car1.num = 1234;
    car1.gas = 20.5;

    car1.show();

    return 0;
}

メンバへのアクセス宣言: setterからしかアクセスできないようにする

class Car {
    private:
        int num;
        double gas;
    public:
        void show();
        void setNumGas(int n, double g);
};

void Car::show(){

    cout << "車のナンバーは" << num << "です。\n";
    cout << "ガソリン量は" << gas << "です。\n";
}

void Car::setNumGas(int n, double g){
    if(g > 0 && g < 1000){
        num = n;
        gas = g;
        cout << "車のナンバーを" << num << "にガソリン量を" << gas << "にしました。\n";
    } else {
        cout << g << "は正しいガソリン量ではありません。\n";
        cout << "ガソリン量を。変更できませんでした。\n";
    }
}


int main() {
    
    Car car1;

    car1.setNumGas(1234, 20.5);
    car1.show();

    cout << "正しくないガソリン量(-10.0)を指定。\n";
    car1.setNumGas(1234, -10.0);
    car1.show();

    return 0;
}

保護したいメンバにprivateをつけて勝手にアクセスできなくする機能をカプセル化といいます。privateとpublicを省略すると全てprivateになる

### 引数にオブジェクトを使用

class Car {
    private:
        int num;
        double gas;
    public:
        int getNum() {return num;}
        double getGas() {return gas;}
        void show();
        void setNumGas(int n, double g);
};

void Car::show(){

    cout << "車のナンバーは" << num << "です。\n";
    cout << "ガソリン量は" << gas << "です。\n";
}

void Car::setNumGas(int n, double g){
    if(g > 0 && g < 1000){
        num = n;
        gas = g;
        cout << "車のナンバーを" << num << "にガソリン量を" << gas << "にしました。\n";
    } else {
        cout << g << "は正しいガソリン量ではありません。\n";
        cout << "ガソリン量を。変更できませんでした。\n";
    }
}

void buy(Car c);

int main() {
    
    Car car1;

    car1.setNumGas(1234, 20.5);
    
    buy(car1);

    return 0;
}

void buy(Car c){
    int n = c.getNum();
    double g = c.getGas();

    cout << "ナンバー" << n << "ガソリン量" << g << "の車を購入しました。\n";
}

引数にポインタや参照を使うこともできる
※メンバが多い場合、引数にポインタを使うと関数の呼び出しが早くなることがある。

void buy(Car* pC);

int main() {
    
    Car car1;

    car1.setNumGas(1234, 20.5);
    
    buy(&car1);

    return 0;
}

void buy(Car* pC){
    int n = pC->getNum();
    double g = pC->getGas();

    cout << "ナンバー" << n << "ガソリン量" << g << "の車を購入しました。\n";
}

### Practice
1. x, 2.○, 3.x, 4.○, 5.○

2.

class Point {
    private:
        int x;
        int y;
    public:
        int getX() {return x;}
        double getY() {return y;}
        void setX(int a);
        void setY(int b);
};

vod Point::setX(int a){

}

vod Point::setY(int b){
    
}

3.

class Point {
    private:
        int x;
        int y;
    public:
        int getX() {return x;}
        double getY() {return y;}
        void setX(int a);
        void setY(int b);
        void show();
};

void Point::setX(int a){
    x = a;
}

void Point::setY(int b){
    y = b;
}

void Point::show() {
    cout << "座標は(" << x << "," << y << ")です。\n";
}

int main() {
    
    int a, b;
    Point point1;

    cout << "X座標を入力してください。\n";

    cin >> a;
    point1.setX(a);

    cout << "Y座標を入力してください。\n";

    cin >> b;
    point1.setY(b);

    point1.show();

    return 0;
}

データメンバは0~10とするとの指定が漏れているが、その他は概ね問題なし。

### typedef
typedefはint型やdouble型などの型に対して新しい名前をつけるためのキーワード

typedef unsigned long int Count;
Count num = 1;

### enum
ユーザー定義型

enum Week{SUN, MON, TUE, WED, THU, FRI, SAT};

int main() {
    
    Week w;
    w = SUN;

    switch(w){
        case SUN: cout << "日曜です。\n"; break;
        case MON: cout << "月曜です。\n"; break;
        case TUE: cout << "火曜です。\n"; break;
        case WED: cout << "水曜です。\n"; break;
        case THU: cout << "木曜です。\n"; break;
        case FRI: cout << "金曜です。\n"; break;
        case SAT: cout << "土曜です。\n"; break;
        default: cout << "何曜かわかりません。\n"; break;
    }

    return 0;
}

### Structure data type(構造体)

struct Car {
    int num;
    double gas;
};

int main() {
    
    Car car1;

    cout << "ナンバーを入力してください。\n";
    cin >> car1.num;

    cout << "ガソリン量を入力してください。\n";
    cin >> car1.gas;

    cout << "車のナンバーは" << car1.num << ":ガソリン量は" << car1.gas << "です。\n";

    return 0;
}

代入もできる

struct Car {
    int num;
    double gas;
};

int main() {
    
    Car car1 = {1234, 25.5};
    Car car2 = {4567, 52.2};

    cout << "car1の車のナンバーは" << car1.num << ":ガソリン量は" << car1.gas << "です。\n";
    cout << "car2の車のナンバーは" << car2.num << ":ガソリン量は" << car2.gas << "です。\n";

    car2 = car1;

    cout << "car2の車のナンバーは" << car2.num << ":ガソリン量は" << car2.gas << "です。\n";    

    return 0;
}

### 構造体の応用

struct Car {
    int num;
    double gas;
};

void show(Car c);

int main() {
    
    Car car1 = {0, 0.0};

    cout << "ナンバーを入力してください。\n";
    cin >> car1.num;

    cout << "ガソリン量を入力してください。\n";
    cin >> car1.gas;

    show(car1);    

    return 0;
}

void show(Car c){
    cout << "車のナンバーは" << c.num << "ガソリン量は" << c.gas << "です。\n";
}

ポインタを使用する

struct Car {
    int num;
    double gas;
};

void show(Car* pC);

int main() {
    
    Car car1 = {0, 0.0};

    cout << "ナンバーを入力してください。\n";
    cin >> car1.num;

    cout << "ガソリン量を入力してください。\n";
    cin >> car1.gas;

    show(&car1);    

    return 0;
}

void show(Car* pC){
    cout << "車のナンバーは" << pC->num << "ガソリン量は" << pC->gas << "です。\n";
}

※参照もできる

### Union data type(共用体)
同時に値を記憶できるのではなく、全体で1つしか値を記憶することができない

union Year {
    int ad;
    int gengo;
};

int main() {
    
    Year myyear;

    cout << "西暦を入力してください。\n";
    cin >> myyear.ad;

    cout << "西暦は" << myyear.ad << "です。\n";
    cout << "元号も" << myyear.gengo << "です。\n";

    return 0;
}

### Practice

struct Person {
    int age;
    double weight;
    double height;
};

int main() {
    
    Person person1, person2;

    cout << "年齢を入力してください。\n";
    cin >> person1.age;
    cout << "体重を入力してください。\n";
    cin >> person1.weight;
    cout << "身長を入力してください。\n";
    cin >> person1.height;

    cout << "年齢を入力してください。\n";
    cin >> person2.age;
    cout << "体重を入力してください。\n";
    cin >> person2.weight;
    cout << "身長を入力してください。\n";
    cin >> person2.height;

    cout << "年齢" << person1.age << "体重" << person1.weight << "身長" << person1.height << "\n";
    cout << "年齢" << person2.age << "体重" << person2.weight << "身長" << person2.height << "\n";

    return 0;
}

↑同じ処理はfor文で回す

struct Person {
    int age;
    double weight;
    double height;
};

void aging(Person* p);

int main() {
    
    Person person1, person2;

    cout << "年齢を入力してください。\n";
    cin >> person1.age;
    cout << "体重を入力してください。\n";
    cin >> person1.weight;
    cout << "身長を入力してください。\n";
    cin >> person1.height;

    cout << "年齢" << person1.age << "体重" << person1.weight << "身長" << person1.height << "\n";

    aging(&person1);

    return 0;
}

void aging(Person* p) {

    cout << "1年経過しました。\n";
    int a = p->age + 1;
    cout << "年齢" << a << "体重" << p->weight << "身長" << p->height << "\n";
}

ポインタで関数を呼び出す際は、入力時はアドレス(&person)で呼び出す。

void func();

int a = 0;

int main() {
    
    int b = 1;

    cout << "main関数ではa, bが使えます。\n";
    cout  << "変数aの値は" << a << "です。\n";
    cout  << "変数bの値は" << b << "です。\n";

    func();

    return 0; 
}

void func() {
    int c = 2;
    cout  << "変数cの値は" << c << "です。\n";
}

a++はローカル変数の加算で、::a++はグローバル変数の加算

### 記憶寿命
ローカル変数: 関数呼び出しの際にメモリが使われる
グローバル変数: プログラム終了時にメモリが解放される

void func();

int a = 0;

int main() {
    
    for(int i=0; i<5; i++)
        func();

    return 0; 
}

void func() {
    int b = 0;
    static int c = 0;

    cout << "変数aは" << a << "変数bは" << b << "変数cは" << c << "です。\n";
    a++;
    b++;
    c++;
}

$ g++ -o sample sample.cpp && ./sample
変数aは0変数bは0変数cは0です。
変数aは1変数bは0変数cは1です。
変数aは2変数bは0変数cは2です。
変数aは3変数bは0変数cは3です。
変数aは4変数bは0変数cは4です。

staticをつけると、グローバル変数と同じ記憶寿命になる。

### 動的なメモリの確保(dynamic allocation)
ポインタ = new 型名;

int* pA;
pA = new int;

int main() {
    
    int* pA;
    pA = new int;

    cout << "動的にメモリを確保しました。\n";

    *pA = 10;

    cout << "動的に確保したメモリを使って" << *pA << "を出力しています。\n";

    delete pA;
    
    cout << "確保したメモリを解放しました。\n";

    return 0;
}

### 配列を動的に確保
pointerName = new 型名[要素数];
delete[] ポインタ名

int main() {
    
    int num;
    int* pT;

    cout << "何人のテストの点数を入力しますか？。\n";

    cin >> num;
    pT = new int[num];

    for(int i=0; i<num; i++){
        cin >> pT[i];
    }

    for(int j=0; j<num; j++){
        cout << j+1 << "番目の人の点数は" << pT[j] << "です。\n";
    }

    delete[] pT;

    return 0;
}

### ファイルの分割
myfunc.c

int max(int x, int y);

myfunc.cpp

int max(int x, int y){
    if (x > y)
        return x;
    else
        return y;
}

#include <iostream>
#include "myfunc.h"
using namespace std;

int main() {
    
    int num1, num2, ans;

    cout << "1番目の整数を入力してください。\n";
    cin >> num1;

    cout << "2番目の整数を入力してください。\n";
    cin >> num2;

    ans = max(num1, num2);

    cout << "最大値は" << ans << "です。\n";

    return 0;
}

$ g++ -o sample sample.cpp myfunc.cpp && ./sample

別ファイルのグローバル変数を使用したい場合はexternを使用する。

### practice
1. ●, 2. ●, 3.●, 4.×, 5.●

int main() {
    
    int* pA;
    pA = new int;
    *pA = 10;
    delete pA;

    return 0;
}

double avg(int t[]);

int main() {
    
    int test[5];

    cout << "5人のテストの点数を入力してください。\n";
    for(int i=0; i<5; i++){
        cin >> test[i];
    }
    double ans = avg(test);
    cout << "5人の平均点は" << ans << "点です。\n";

    return 0; 
}

double avg(int t[]){
    double sum = 0;

    for(int i=0; i<5; i++){
        sum += t[i];
    }
    return sum/5;
}

ポインタを引数で渡すように良く書かれる

double avg(int* pT);

int main() {
    
    int test[5];

    cout << "5人のテストの点数を入力してください。\n";
    for(int i=0; i<5; i++){
        cin >> test[i];
    }
    double ans = avg(test);
    cout << "5人の平均点は" << ans << "点です。\n";

    return 0; 
}

double avg(int* pT){
    double sum = 0;

    for(int i=0; i<5; i++){
        sum += *(pT+i);
    }
    return sum/5;
}

$ g++ -o sample sample.cpp && ./sample
5人のテストの点数を入力してください。
33
12
14
12
11
5人の平均点は16.4点です。

### 文字列と配列
文字列は配列だけでなく、ポインタでも扱える

int main() {
    
    char str[] = "Hello";

    cout  << str << "\n";

    return 0; 
}

int main() {
    
    char* str = "Hello";

    cout  << str << "\n";

    return 0; 
}

$ g++ -o sample sample.cpp && ./sample
sample.cpp: In function ‘int main()’:
sample.cpp:6:17: warning: ISO C++ forbids converting a string constant to ‘char*’ [-Wwrite-strings]
6 | char* str = “Hello”;
| ^~~~~~~
Hello

int main() {
    
    char str[] = "Hello";

    cout  << "Hello\n";

    for(int i=0; str[i]!='\0'; i++){
        cout << str[i] << '*';
    }
    cout  << "\n";

    return 0; 
}

c++の文字列は必ず\0で終わる

### 文字列の標準ライブラリ

#include <iostream>
#include <cstring>
using namespace std;

int main() {
    
    char str[100];

    cout  << "文字列(英数字)を入力してください。\n";

    cin >> str;

    cout  << "文字列の長さは" << strlen(str) << "です。\n";

    return 0; 
}

strcatで文字列を連結する。strcpyは代入格納

int main() {
    
    char str0[20];
    char str1[10];
    char str2[10];

    strcpy(str1, "Hello");
    strcpy(str2, "Goodbye");
    strcpy(str0, str1);
    strcat(str0, str2);

    cout  << "配列str1は" << str1 << "です。\n";
    cout  << "配列str2は" << str2 << "です。\n";
    cout  << "配列str0は" << str0 << "です。\n";

    return 0; 
}

### practice

int max(int x[]){
    int maxnum = 0;
    for(int i=0; i<5; i++) {
        if(x[i] > maxnum) {
            maxnum = x[i];
        }
    }
    return maxnum;
}

int main() {
    
    int result[5];

    cout  << "テストの点数を入力してください。\n";

    for(int i=0; i<5; i++) {
        cin >> result[i];
    }

    int num = max(result);
    cout  << "テストの最高点は" << num << "点です。\n";

    return 0; 
}

int length(char* str){
    int i = 0;
    while(str[i]){
        i++;
    }
    return i;
}

int main() {
    
    char str[10];
    cout  << "文字列を入力してください。\n";

    cin >> str;
    int len = length(str);

    cout  << "文字列の長さは" << len << "です。\n";

    return 0; 
}

maxは最初から x[0]と宣言してしまった方が効率的

int max(int x[]){
    int m = x[0];
    for(int i=0; i<5; i++){
        
    }
}

int count(char str[], char ch){
    int n = 0;
    for(int i=0; i < strlen(str); i++){
        if(str[i] == ch){
            n++;
        }
    }
    return n;
}

int main() {
    
    char str[10];
    char ch;

    cout  << "文字列を入力してください。\n";

    cin >> str;

    cout  << "文字列から探す文字を入力してください。\n";
    cin >> ch;

    int n = count(str, ch);

    cout  << str << "の中に" << ch << "は" << n << "個です。\n";

    return 0; 
}

### 配列の要素を出力

int main() {
    
    int test[5];

    test[0] = 80;
    test[1] = 60;
    test[2] = 22;
    test[3] = 50;
    test[4] = 75;
    
    for(int i=0; i<5; i++) {
        cout << i+1 << "番目の人の点数は" << test[i] << "です。\n";
    }

    return 0; 
}

### キーボードから入力

int main() {
    
    const int num = 5;
    int test[num];

    cout << num << "人の点数を入力してください。\n";
    for(int i=0; i<num; i++) {
        cin >> test[i];
    }
    
    for(int j=0; j<num; j++) {
        cout << j+1 << "番目の人の点数は" << test[j] << "です。\n";
    }

    return 0; 
}

### 配列の要素をソートする

int main() {
    
    const int num = 5;
    int test[num];

    cout << num << "人の点数を入力してください。\n";
    for(int i=0; i<num; i++) {
        cin >> test[i];
    }

    for(int s=0; s<num-1; s++) {
        for(int t=s+1; t<num; t++) {
            if(test[t] > test[s]){
                int tmp = test[t];
                test[t] = test[s];
                test[s] = tmp;
            }
        }
    }
    
    for(int j=0; j<num; j++) {
        cout << j+1 << "番目の人の点数は" << test[j] << "です。\n";
    }

    return 0; 
}

### 多次元配列

int main() {
    
    const int sub = 2;
    const int num = 5;

    int test[sub][num];

    test[0][0] = 80;
    test[0][1] = 60;
    test[0][2] = 22;
    test[0][3] = 50;
    test[0][4] = 75;
    test[1][0] = 90;
    test[1][1] = 55;
    test[1][2] = 68;
    test[1][3] = 72;
    test[1][4] = 58;
    
    for(int i=0; i<num; i++) {
        cout << i+1 << "番目の人の国語の点数は" << test[0][i] << "です。\n";
        cout << i+1 << "番目の人の算数の点数は" << test[1][i] << "です。\n";
    }

### 配列とポインタ
配列のアドレス
&test[0]
&test[1]

配列名を記載しただけで、先頭要素のアドレスを表す
test

int main() {
    
    int test[5] = {80, 60, 55, 22, 75};

    cout << "test[0]の値は" << test[0] << "です。\n";
    cout << "test[0]のアドレスは" << &test[0] << "です。\n";
    cout << "testの値は" << test << "です。\n";
    cout << "つまり*testの値は" << *test << "です。\n";

    return 0; 
}

$ g++ -o sample sample.cpp && ./sample
test[0]の値は80です。
test[0]のアドレスは0xfffff9b40360です。
testの値は0xfffff9b40360です。
つまり*testの値は80です。

*testは配列の先頭要素の値となる。

### ポインタの演算

int main() {
    
    int test[5] = {80, 60, 55, 22, 75};

    cout << "test[0]の値は" << test[0] << "です。\n";
    cout << "test[0]のアドレスは" << &test[0] << "です。\n";
    cout << "testの値は" << test << "です。\n";
    cout << "test+1の値は" << test+1 << "です。\n";
    cout << "*(test+1)の値は" << *(test+1) << "です。\n";

    return 0; 
}

$ g++ -o sample sample.cpp && ./sample
test[0]の値は80です。
test[0]のアドレスは0xffffe4e0e070です。
testの値は0xffffe4e0e070です。
test+1の値は0xffffe4e0e074です。
*(test+1)の値は60です。

### 参照
型名& 参照名 = 変数

int main() {
    
    int a = 5;
    int& rA = a;

    cout << "変数aの値は" << a << "です。\n";
    cout << "参照rAの値は" << rA << "です。\n";

    rA = 50;

    cout << "rAに50を代入しました。\n";
    cout << "参照rAの値は" << rA << "です。\n";
    cout << "変数aの値は" << a << "です。\n";
    
    cout << "参照rAのアドレスは" << &rA << "です。\n";
    cout << "変数aのアドレスは" << &a << "です。\n";

    return 0; 
}

$ g++ -o sample sample.cpp && ./sample
変数aの値は5です。
参照rAの値は5です。
rAに50を代入しました。
参照rAの値は50です。
変数aの値は50です。
参照rAのアドレスは0xfffff784567cです。
変数aのアドレスは0xfffff784567cです。

参照rAはaと全く同じ
参照の場合は引数を変更することができる。

void swap(int& x, int& y);

int main() {
    
    int num1 = 5;
    int num2 = 10;

    cout << "変数num1の値は" << num1 << "です。\n";
    cout << "変数num2の値は" << num2 << "です。\n";

    cout << "変数num1とnum2の値を交換します。\n";

    swap(num1, num2);
    
    cout << "変数num1の値は" << num1 << "です。\n";
    cout << "変数num2の値は" << num2 << "です。\n";

    return 0; 
}

void swap(int& x, int& y){
    int tmp;

    tmp = x;
    x = y;
    y = tmp;
}

$ g++ -o sample sample.cpp && ./sample
変数num1の値は5です。
変数num2の値は10です。
変数num1とnum2の値を交換します。
変数num1の値は10です。
変数num2の値は5です。

関数の引数にポインタ、参照を使うと、呼び出し元の実引数を変更できる

### Practice
1. x, 2.×, 3.○

void add(int* num1, int* num2, int num3);

int main() {
    
    int num1, num2, num3;

    cout << "2科目分の点数を入力してください。\n";

    cin >> num1;
    cin >> num2;

    cout << "加算する点数を入力してください。\n";

    cin >> num3;

    add(&num1, &num2, num3);
    
    cout << "科目1は" << num1 << "点となりました。\n";
    cout << "科目2は" << num2 << "点となりました。\n";

    return 0; 
}

void add(int* num1, int* num2, int num3) {
    *num1 += num3;
    *num2 += num3;
}

void add(int& num1, int& num2, int num3);

int main() {
    
    int num1, num2, num3;

    cout << "2科目分の点数を入力してください。\n";

    cin >> num1;
    cin >> num2;

    cout << "加算する点数を入力してください。\n";

    cin >> num3;

    add(num1, num2, num3);
    
    cout << "科目1は" << num1 << "点となりました。\n";
    cout << "科目2は" << num2 << "点となりました。\n";

    return 0; 
}

void add(int& num1, int& num2, int num3) {
    num1 += num3;
    num2 += num3;
}

アドレスは16進数を使ってx01000, 0x1004などで表す
メモリのアドレスは&変数名を使う

int main() {
    
    int a;
    a = 5;

    cout << "変数aの値は" << a << "です。\n";
    cout << "変数aのアドレスは" << &a << "です。\n";

    return 0; 
}

$ g++ -o sample sample.cpp && ./sample
変数aの値は5です。
変数aのアドレスは0xffffc948bd84です。

### ポインタ
アドレスを格納する特殊な変数

int main() {
    
    int a;
    int* pA;

    a = 5;
    pA = &a;

    cout << "変数aの値は" << a << "です。\n";
    cout << "変数aのアドレス(&a)は" << &a << "です。\n";
    cout << "ポインタpAの値は" << pA << "です。\n";

    return 0; 
}

$ g++ -o sample sample.cpp && ./sample
変数aの値は5です。
変数aのアドレス(&a)は0xffffe5f9f30cです。
ポインタpAの値は0xffffe5f9f30cです。

ポインタから変数の値を知るには *pAとする

int main() {
    
    int a;
    int* pA;

    a = 5;
    pA = &a;

    cout << "変数aの値は" << a << "です。\n";
    cout << "変数aのアドレス(&a)は" << &a << "です。\n";
    cout << "ポインタpAの値は" << pA << "です。\n";
    cout << "*pAの値は" << *pA << "です。\n";

    return 0; 
}

$ g++ -o sample sample.cpp && ./sample
変数aの値は5です。
変数aのアドレス(&a)は0xffffc90c856cです。
ポインタpAの値は0xffffc90c856cです。
*pAの値は5です。

### ポインタに別のアドレスを代入する

int main() {
    
    int a = 5;
    int b = 10;
    int* pA;
    pA = &a;

    cout << "変数aの値は" << a << "です。\n";
    cout << "ポインタpAの値は" << pA << "です。\n";
    cout << "*pAの値は" << *pA << "です。\n";

    pA = &b;
    
    cout << "変数bの値は" << b << "です。\n";
    cout << "ポインタpAの値は" << pA << "です。\n";
    cout << "*pAの値は" << *pA << "です。\n";

    return 0; 
}

$ g++ -o sample sample.cpp && ./sample
変数aの値は5です。
ポインタpAの値は0xffffd6b96088です。
*pAの値は5です。
変数bの値は10です。
ポインタpAの値は0xffffd6b9608cです。
*pAの値は10です。

### ポインタを使って変数を変更する

int main() {
    
    int a = 5;
    int* pA;
    pA = &a;

    cout << "変数aの値は" << a << "です。\n";

    *pA = 50;
    
    cout << "*pAに50を代入しました。\n";
    cout << "aの値は" << a << "です。\n";

    return 0; 
}

$ g++ -o sample sample.cpp && ./sample
変数aの値は5です。
*pAに50を代入しました。
aの値は50です。

なぜこのような機能があるか？？

### 引数とポインタ
swapの誤ったコード

void swap(int x, int y);

int main() {
    
    int num1 = 5;
    int num2 = 10;

    cout << "変数num1の値は" << num1 << "です。\n";
    cout << "変数num2の値は" << num2 << "です。\n";

    cout << "変数num1とnum2の値を交換します。\n";

    swap(num1, num2);
    
    cout << "変数num1の値は" << num1 << "です。\n";
    cout << "変数num2の値は" << num2 << "です。\n";

    return 0; 
}

void swap(int x, int y){
    int tmp;

    tmp = x;
    x = y;
    y = tmp;
}

$ g++ -o sample sample.cpp && ./sample
変数num1の値は5です。
変数num2の値は10です。
変数num1とnum2の値を交換します。
変数num1の値は5です。
変数num2の値は10です。

通常の値渡しでは、実引数を変更することができない。

アドレスを引数にすると、変更することができる。

void swap(int* x, int* y);

int main() {
    
    int num1 = 5;
    int num2 = 10;

    cout << "変数num1の値は" << num1 << "です。\n";
    cout << "変数num2の値は" << num2 << "です。\n";

    cout << "変数num1とnum2の値を交換します。\n";

    swap(&num1, &num2);
    
    cout << "変数num1の値は" << num1 << "です。\n";
    cout << "変数num2の値は" << num2 << "です。\n";

    return 0; 
}

void swap(int* px, int* py){
    int tmp;

    tmp = *px;
    *px = *py;
    *py = tmp;
}

$ g++ -o sample sample.cpp && ./sample
変数num1の値は5です。
変数num2の値は10です。
変数num1とnum2の値を交換します。
変数num1の値は10です。
変数num2の値は5です。

### 関数のオーバーロード
引数の型が異なる同じ名前の関数を複数定義することを関数のオーバーロードという。

int main() {
    
    int a, b;
    double da, db;

    cout << "2つの整数を入力してください。\n";
    cin >> a >> b;

    cout << "2つの小数を入力してください。\n";
    cin >> da >> db;

    int ans1 = max(a, b);
    double ans2 = max(da, db);

    cout << "整数値の最大値は" << ans1 << "です。\n";
    cout << "小数値の最大値は" << ans2 << "です。\n";

    return 0; 
}

int max(int x, int y) {
    if (x > y)
        return x;
    else
        return y;
}

double max(double x, double y) {
    if (x > y)
        return x;
    else
        return y;
}

### 関数テンプレート
関数テンプレートの宣言は
template
関数の宣言

仮引数の型名にテンプレート引数を使う
L 型が異なるが同じ処理の場合に纏めて使用できる。

template <class T>
T maxt(T x, T y) {
    if (x > y)
        return x;
    else
        return y;
}

int main() {
    
    int a, b;
    double da, db;

    cout << "2つの整数を入力してください。\n";
    cin >> a >> b;

    cout << "2つの小数を入力してください。\n";
    cin >> da >> db;

    int ans1 = maxt(a, b);
    double ans2 = maxt(da, db);

    cout << "整数値の最大値は" << ans1 << "です。\n";
    cout << "小数値の最大値は" << ans2 << "です。\n";

    return 0; 
}

### Practice

int square(int x) {
    return x * x;
}

int main() {
    
    int x, res;
    cout << "整数を入力してください。\n";
    cin >> x;

    res = square(x);

    cout << x << "の2乗は" << res << "です。\n";

    return 0; 
}

int square(int x) {
    return x * x;
}

double square(double x) {
    return x * x;
}

int main() {
    
    int x, res;
    double bx, bres;
    cout << "整数を入力してください。\n";
    cin >> x;

    res = square(x);

    cout << x << "の2乗は" << res << "です。\n";

    cout << "小数を入力してください。\n";
    cin >> bx;

    bres = square(bx);

    cout << bx << "の2乗は" << bres << "です。\n";

    return 0; 
}

inline

inline int square(int x) { return x * x;}

inline double square(double x) { return x * x;}

関数テンプレート

template <class T>
T squaret(T x){
    return x * x;
}

int main() {
    
    int x, res;
    double bx, bres;
    cout << "整数を入力してください。\n";
    cin >> x;

    res = squaret(x);

    cout << x << "の2乗は" << res << "です。\n";

    cout << "小数を入力してください。\n";
    cin >> bx;

    bres = squaret(bx);

    cout << bx << "の2乗は" << bres << "です。\n";

    return 0; 
}