C++　まとめ

#他のモジュールとの名前の衝突を極力避けるため名前空間という機能がある
特定の名前空間を可視状態にするため

using namespace space-name;

を指定することで

```:
std::cout << "Kitty on your lap";
↓
cout << "Kitty on your lap";
```

[std::]が不要


#関数のプロトタイプについて
voidを省略すると値を受け取らない関数を意味します

/*C++では、voidを省略できる*/
void func();

戻り値がある場合は、必ず何らかの値を返さなくてはけない

```:
int main() {
func();
return 0;
```

#C++では
class はデフォルトのアクセシビリティが private
struct はデフォルトのアクセシビリティが public


#bool型変数には、C++で追加されている予約語の true 及び false いずれかを代入します
trueは0以外の値、falseは0を意味します

#クラスの宣言は class キーワードを使用します
クラス内部で定義されるデータはメンバと呼びます
オブジェクト指向ではアクセス制御という概念があり、外部からデータにアクセスして良いものと、ダメなものを明示的に分けます。
デフォルトでデータにアクセスできないのです
そこで、外部からアクセスするにはpublicキーワードでデータを公開する必要がある。

```:
#include <iostream>
using namespace std;

class Kitty {
public:
char *str;
} obj ;

int main() {
obj.str = "Kitty on your lap";
cout << obj.str;

return 0;
}
```

定義されている obj は、Kitty型の変数
obj のようなクラス型変数を、オブジェクト指向ではオブジェクトと呼びます
アクセス方法も構造体と同じで クラス型変数名.メンバ名 

というようにアクセスします

クラスに関連付けられた関数をメンバ関数
上記のものはメンバ変数になる。（メソッドととも呼ぶ）


```:
#include <iostream>
using namespace std;

class Kitty {
private:
int point;
public:
void setPoint(int i);
int getPoint(int i);
};

void Kitty::setPoint(int i) {
point = i;
}

int Kitty::getPoint(int i) {
point += i;
return point;
}

int main() {
Kitty obj;
obj.setPoint(0);
for (int i = 0 ; i < 10 ; i++)
cout << obj.getPoint(i) << "\n";
return 0;
}

```
スコープ解決演算子( :: ) を用いてクラスと関数名を指定
publicに対するアクセス不能領域をprivateキーワードで明示できる


#コンストラクタ
※コンストラクタには戻り値は存在しません


```:
#include <iostream>
using namespace std;

class Kitty {
public:
Kitty();
} obj ;

Kitty::Kitty() {
cout << "Kitty on your lap\n";
}

int main() {
Kitty obj;
return 0;
}

```

コンストラクタはオブジェクトの発生時に常に呼び出される
また、コンストラクタ関数も引数を受け取ることができます



#オブジェクトの破棄
オブジェクトの破棄もコンストラクタ同様に自動化することでつまらないバグやメモリリークをできるだけ避けることができる
コンストラクタの逆の処理を担当するものがデストラクタ関数です

デストラクタ関数も、コンストラクタ関数と同じく戻り値はありません、また仮引数も受け取らない（渡せない）という特徴がある。

```:

#include <iostream>
using namespace std;

class Kitty {
public:
~Kitty();
};

Kitty::~Kitty() {
cout << "Kitty on your lap\n";
}

void createKitty() {
Kitty obj;
}

int main() {
createKitty();
createKitty();
return 0;
}

```

関数 createKitty() はKittyオブジェクトを内部で生成します
しかし、関数が終了するとともにオブジェクトが破棄される

ためデストラクタが呼び出されます
2度 main() 関数内で createKitty() 関数を呼び出しているので
2度デストラクタ関数が呼び出されるのを確認してください



#識別子の衝突
ローカル変数名とグローバル変数名が同じだったとき
クラスのメンバ関数内とメンバ変数でも発生

関数の中で宣言した変数をローカル変数といいその関数内でしか参照できません
main関数の外で宣言した変数は、グローバル変数といい、すべての関数の中から直接アクセスすることが可能

```:
#include <iostream>
using namespace std;

class Kitty {
public:
char *str;
void print(char *);
};

void Kitty::print(char *str) {
cout << str;
}

int main() {
Kitty obj;
obj.str = "Kitty on your lap";
obj.print("Di_Gi_Gharat");
return 0;
}

```

Kittyクラスのメンバ関数 print() の仮引数の変数名が str であり
Kittyクラスのメンバ変数 str と同一です
print()メンバ関数を実行すると、予想どおりローカル変数を優先する
この場合、仮引数の str を標準出力に表示します
結果として Di_Gi_Gharat という文字列が画面に表示された


これを解決するのに、メンバ関数では内部でメンバ変数を明示する
こうすれば、同時にメンバ関数内ローカル変数と、メンバ変数を扱える

ローカル変数との衝突や、メンバ変数であることを明示したいとき
メンバ関数では スコープ解決演算子 を用いる

```:
#include <iostream>
using namespace std;

class Kitty {
public:
char *str;
void print(char *);
};

void Kitty::print(char *str) {
cout << str << '\n';
cout << Kitty::str << '\n';
}

int main() {
Kitty obj;
obj.str = "Kitty on your lap";

obj.print("Di_Gi_Gharat");
return 0;
}

```
このプログラムのprint()メンバ関数は
メンバ変数とローカル変数 str をスコープ解決演算子で区別している
最初に出力する str は仮引数で得た文字列、Kitty::str は

Kittyクラスのメンバ変数を示しています

#グローバルスコープ

```:
#include <iostream>
using namespace std;

char *str = "Kitty on your lap\n";

int main() {
char *str = "Card Captor Sakura\n";

cout << str;
cout << ::str;
return 0;
}

```
グローバル変数 str と main() 関数内のローカル変数 str 

が存在しています
main()関数で、グローバルスコープ解決演算子が用いられている

```:
#include <iostream>
using namespace std;

char *str = "Di_Gi_Gharat\n";

class Kitty {
public:
char *str;
void print(char *str);
} obj ;

void Kitty::print(char *str) {
cout << str << Kitty::str << ::str;
}

int main() {
obj.str = "Kitty on your lap\n";
obj.print("Card Captor Sakura\n");
return 0;
}
```
名前の衝突は変数だけではなく関数も同様


```:
#include <iostream>
using namespace std;

void function() {
cout << "Di_Gi_Gharat\n";
}

class Kitty {
void function();
public:
Kitty();
} obj ;

Kitty::Kitty() {
::function();
Kitty::function();
}

void Kitty::function() {
cout << "Kitty on your lap\n";
}

int main() {
return 0;
}
```

グローバルな関数（C言語の通常な関数） function() と
Kittyクラスのプライベートエリアの function() が定義されています
Kitty()コンストラクタで、スコープ演算子を用いてそれぞれを呼び出しています



参照は変数の別名的存在
参照を宣言するには、宣言時に変数の前に アンパサンド 「 & 」 を指定します
変数のアドレスを出力する & 演算子とは異なるので注意してください


```:
#include <iostream>
using namespace std;

int main() {
int i = 100;
int &ref = i;

ref++;

cout << i << " : " << ref <<  '\n';
cout << &i << " : " << &ref;

return 0;
}

```

```:実行結果
101 : 101
0065FE00 : 0065FE00

```

変数 i と、参照 ref のアドレスはまったく同じ
参照の値を更新することは変数の値を更新することに等しい
参照は必ず宣言時に初期化します
参照の配列は作れないと言うのも特徴