構造体・・・型を定義するのみで、宣言と同時に値を代入はできない。

　　そして、例えばポインタ変数をメンバにしたとき、

　　プロトタイプ宣言をしない間はアドレスは確保されない。

１．まずは構造体（「ある人を含む集合」の要素（給料など））を定義。構造体名を集合の名前（例えば企業名）にする

２．struct 構造体名　従業員名（集合に含まれる人）

　　でプロトタイプ宣言（ここでは変数名を宣言するのみであるのに注意）

３．そして従業員.要素名でオブジェクトを生成

（ここで構造体名が出てこないことに注意！あくまでも構造体名はデータ型に名前を付けたものに過ぎない）

まとめ

構造体名はintなどと同じように使うが、その前にstruct　をつけなくてはならない。

オブジェクトの生成時には構造体名を記述しない。

代入：異なる従業員の構成要素（給料など）が同じ場合、従業員名＝従業員名　とすることで

　　　構造体のメンバを全てコピーできる

構造体とポインタ

：構造体の実態変数(struct 構造体名 変数)に対して p = &変数 となっている場合、

　アロー演算子 -> で p -> メンバ名 で表す（変数.メンバ名　と同じ意味）

：関数に構造体を引数として渡すときはポインタ型の変数で渡すというルールがある。

オブジェクトとは処理の所有者 ○○.メンバ名　の　○○部分がオブジェクト！

○○毎に処理をまとめて考えることができるのでプログラムが見やすくなる！

クラスと構造体の違いと関数の定義

classは構造体とは違い、実態変数の宣言時には

struct 構造体名 変数とはせず、クラス名 変数 とするだけでよい。

ただし、例えば

class func{

public: 

int function();

};

とした場合には、

int func :: function(){

}

つまり、「関数の型名　クラス名　：：　関数名」の形で、型名も記述しないといけない。

関数の呼び出しは、構造体と同じく 実態変数名. 関数名；でよい

void・・・すでに決まった値を操作せずに判定にのみ使うときの型。数字には操作を加えない。

クラスの定義はheaderファイル、メンバ関数などの実装はcppファイルとするとよい

クラス、構造体は、同じ構成要素区分をもつ複数のもの（オブジェクト）を　同じ型で管理するためのもの！

同じ一つの型で複数のオブジェクトを評価することができるので便利！

例えば、野球選手の成績をまとめるときに選手の名前がオブジェクトになり、同じ型で比較することができる！

#include "test.h"　とするとリンクが完了。

オブジェクト指向プログラミングの３本柱

１．継承・・・他のクラスのメンバを引き継いで新たなクラスを定義すること

２．カプセル化・・・クラスのメンバを部分的に隠す

３．ポリモーフィズム・・・「戻り値の型だけでなく引数の型もしくは数が違う」同じ名前のもの

　（特に関数の場合をオーバーロード）を別の機能をもたせる

オーバーロードの例

class Myclass {

public:

int func(int a);

double func(double b);

double func(double a, b, c);

};

１時間３０分

static関数・・・これをデータ型の前につけることで、そのコードがそのファイル中での処理でのみ有効になる。

同じ関数や文字が複数のファイルで定義されているときに

片方にstaticをつけることでエラーを回避できる。

逆に、関数内でstatic int などと定義することで

定義されたローカル変数がその関数を抜けた後でも有効になる。

ただし、スコープは関数内である。同じ関数をもう一度使うときにしか利用できない。

（さらに逆に言えば、関数内で定義されたローカル変数は他の関数内で利用することはできない。）

グローバル変数・・・main関数を含め、関数の外で定義された変数

カプセル化・・・privateでクラス内で定義された他のメンバ関数以外では

そのプライベート変数を利用できないようにすること。

protectedで定義された変数は、継承されたときのみ引き続き使える

コンストラクタ（関数）・・・クラス名と同じ関数名を持ち、戻り値型も引数ももたない。（voidもつけない）

　　クラス内で定義し、変数を初期化するために使うことが多い。

　　オブジェクトが生成されるごとに実行され、初期化が行われる。

　　グローバルオブジェクトでは一度だけ呼び出され、

　　ローカルオブジェクトでは何度でも呼び出される

　　アドレスを参照できない関数である

　　初期化に使う値を引数として持たせることもできる

デストラクタ（関数）・・・オブジェクトを破棄するときに使われる。コンストラクタに「～」（チルダ）

　をつけたものになる。破棄するときはメモリの解放なども

　同時に関数に含んでおく必要があるかもしれないので注意する

　関数スコープを「外れた」時点でオブジェクトを破棄する。

　なので、コンストラクタとは実行されるタイミングが少し遅くなる

　ただしグローバルオブジェクトはプログラムの終了時に破棄される

　アドレスを参照できない関数である

継承・・・class Newclass : public Oldclass{

 }; で宣言する。継承元のクラスは全て引き継がれるので、

　継承先のクラスにはメンバを追加する必要はない。

　継承先のクラスで新たにメンバのアクセス指定子を更新することができる。

　例：public Oldclassとすると全てのメンバが変わらず継承される。

　　　private Oldclassとすると全てのメンバがprivateに更新される

     protected Oldclassとするとpublicなメンバのみprotectedに更新される

     (つまり、privateだけは不変)

継承とコンストラクタ・・・新しいクラスでコンストラクタ・デストラクタを定義しておけば、

　新しいクラスのオブジェクトの生成に応じて

　古いコンストラクタ・デストラクタも呼び出される。

　順序は旧コンスト→新コンスト　　新デスト→旧デスト

　二つのコンストラクタが古いクラスで定義されている場合、

　Newclass::Newclass(int m, int n) : myclass(m){   }

 のようにしてどちらを使うか指定しなくてはいけない

　：移行をイニシャライザという

　引数を持たなければ特に宣言は必要ない

オーバーライドとvirtual ・・・継承先のクラスで継承したくないものがあれば、

　　　そのメンバをもう一度定義しなおすことができる（オーバーライド）

　　　ただし、元のクラスでvirtual int func のようにvirtualをつけていないと

　　　上書きはできない。

基本クラスのポインタと派生クラス・・・(main関数内で定義された)基本クラスのポインタを

　　　　　派生クラスのオブジェクトのポインタ(&)に代入できる。

　　　　　ただし、基本クラスのポインタが継承されていることが条件

　　　　　ここで基本クラスのポインタを配列系にしておく(p[i])と

　 　　　（もしくは配列のように利用すると）派生クラスのオブジェクトを

　　　　　特にfor文などで一気に実行することができるようになる。

　   

純粋仮想関数・・・virtual void func() = 0;のように０を代入した形の関数。継承したときに

　誤ってこの関数が実行されてもオブジェクトは生成されず、トラブルを防げる。

メモリの確保と解放＝オブジェクトの作成と破棄

staticとクラス・・・static変数（静的メンバ変数)は、オブジェクトを作成する前からメモリを確保している。

　　この場合、クラス名：：静的メンバ変数と記述する。（.の代わりに：：を使う）

　　ただし、静的変数の実態となるグローバル変数を定義する必要がある。

　　｛データ型　クラス名：：グローバル変数名（名前は静的変数と同じ）　＝　初期値｝

　　と記述すればよい

　　オブジェクトができてしまえば普通のメンバ変数として使える。

オブジェクトの数を数える・・・コンストラクタ関数内にカウント変数を入れるだけで可能

　　　ただし、スコープを外れたときに初期化を防ぐためにstaticを使うこと。

動的オブジェクト・・・クラス名　ポインタ変数名 new クラス名; と記述すれば、

　　　動的オブジェクトを生成できる。delete ポインタ変数名;　で開放できる

　　　動的オブジェクトのメリットは、for文などで作成と破棄を繰り返すことで

　　　メモリを節約できることにある。

メモリ領域の区分・・・コード領域　：命令が格納される

　　　データ領域　：グローバル変数や静的変数を格納

　　　スタック領域：引数、ローカル変数を格納

　　　ヒープ領域　：new malloc()の変数を格納

コンポジション（合成）・・・クラスの中に他クラスのオブジェクトを含ませること

　　メンバオブジェクトは、そのクラスのオブジェクトが呼ばれると同時に生成される

　　（コンストラクタと同様）

復習：オブジェクトとメンバの順番・・・オブジェクト名.メンバ名というふうに記述する。

　　　これは、先にオブジェクト名を指定することで

　　　「誰の」要素であるかを先に明示するようになっているのである

　　　プログラム上でいうとこうなる

　　　１．クラスの定義＝ここでメンバ名を定義

　　　２、オブジェクトの作成

　　　３．オブジェクトを利用　オブジェクト.メンバ名

合成時のコンスト/デストラクタ・・・元クラスのコンスト→継承先クラスのコンスト

　→継承先のクラスのデスト→元クラスのデスト

　元クラスのコンストが先に呼ばれるので、継承先クラスでも

　元クラスの要素を使うことができる

　ただし、メンバオブジェクトが引数を持つコンストラクタを持つ場合、

　コンストラクタ関数の定義式：メンバ名（引数）

　でイニシャライズする必要がある。

　（引数なしの場合はメンバ名ではなくクラス名）

関数の引数にオブジェクトを使う・・・関数のプロトタイプ宣言時にはコンストラクタが呼び出されるが、

　　main関数で使うときにはコンストラクタは呼び出されない

　　（ただし、デストラクタは呼び出される）

　　これは、コンストラクタにnew,デストラクタにdeleteを使っているときは

　　特に注意しなくてはならない点である

引数にポインタを渡す・・・コンストラクタもデストラクタも呼び出されない

コピーコンストラクタ・・・通常のコンストラクタに加えて、関数の引数としてオブジェクトが使われたときでも

　呼び出されるコンストラクタ。メモリリークを防ぐために使う

　宣言は　クラス名（const クラス名　&obj)(関数の引数なので任意)

　コピー関数内には、各メンバをコピー（代入）する文を書くこと！

　＆のことを参照と呼ぶ

　代入時などは呼び出されない

　　

メンバの一斉コピー・・・オブジェクト＝オブジェクトとすると、メンバがすべてコピーされる

ただし、ポインタをメンバにもつオブジェクトの代入には気を付ける。

これは、代入する前のポインタが存在したままであるのに、

それにアクセス（特に解放）する方法を失うから。

フレンド関数・・・メンバ関数ではないにもかかわらず、private、protectedな部分でも利用可能な関数

　クラス内で宣言する必要がある。 friend 戻り値データ型 関数名（クラス名　引数）

　で宣言。使うときは friend を抜いて、

　普通の関数（メンバ関数とは別）と同じように記述すればよい

　フレンド関数は継承されず、派生クラスでは利用できない。

前方参照・・・先にクラス（データ型）の存在を宣言しておくこと。変数までは宣言しなくてもよい

　　　複数のクラスでクラス間で変数を比較するときなどに使われる方法。

　　　（どちらでも同じ処理をするのでどうしても

クラスの定義より先にそのクラスのメンバを利用してしまうことになる）

thisポインタ・・・普段は省略されている。メンバ変数名と引数名が同じとき、

　this->number = number; というように左辺ががメンバ変数であると明示しなくてはいけない。

代入演算子のオーバーロード・・・

宣言時

（クラス内で宣言）

クラス名　＆operator「演算子」(クラス名 ＆任意のオブジェクト名);

実行時

クラス名　＆クラス名（コンストラクタ）：： operator「演算子」(クラス名 ＆任意のオブジェクト名）

最後に　代入の場合　　return *thisをつける（thisはthisポインタ）

＋などの場合　return ans などとする

テンプレートクラス・・・template <class 仮のデータ型名> class クラス名{  

仮のデータ型　変数;

}

int main(){

クラス名<int(doubleなどもok)> obj;

(仮のデータ型がintとして扱われる）

エラー1error LNK1104: ファイル 'glew32.lib' を開くことができません。

僕なりにまとめてみました。
学習時間・・・１時間３０分（ｐ１４～２６）
クラスは
C言語でいう構造体＋他のクラスからのそのクラスの変数を守れる機能　という解釈をしました。

クラス・・・構造体に似ている。クラス名＝型名(型の定義。メモリは使わない）

メンバ（メンバ関数）・・・クラス内で宣言される関数と変数（他のクラスに対して非公開。

　自クラスからの影響しか受けない

　　ただし、public: とすると以下の部分は公開される

スコープ解決演算子"::"・・・クラス内で宣言した関数を定義するには、

クラス名::関数名{}という形をとらなければならない。

オブジェクト・・・クラス（構造体）で定義された新しい型で宣言された変数のこと。

　ob.a,ob,bなどと構造体とほぼ同じ記述の仕方をする

間違った解釈などあれば教えていただけると助かります。