例外をもう一度送って☆彡
こんにちは
ぷないしんです。
今日はプログラム上で例外をキャッチしたとき、その例外の状態に対処できない、あるいは対処すべきではないと判断される場合に行うのが、例外の再送出です。
再送出ではちょっとピンとこないので例外の処理の仕方の話をしようと思います。
例外を補足したときに、それに対する処理が完了できないのであれば、その例外をそのまま再送出するか、あるいは別の例外として送出するとよいということなんですが、さっそく具体例を見ていきましょう。
rethrow.cpp
#include <iostream>
using namespace std;
void func()
{
int x;
cout << "整数を入力：";
cin >> x;
try {
switch (x){
case 1: throw 1;
cout << "1\n";
case 7: throw 7.0;
cout << "7\n";
case 99: throw "99例外";
cout << "99\n";
}
}
catch(int){
cout << "func : int型の例外\n";
}
catch(double){
cout << "func : double型の例外\n";
throw "7";
}
catch (const char*){
cout << "func:文字列型の例外";
throw;
}
}
int main()
{
try{
func();
}
catch (const char* str){
cout << "main:文字列\"" << str << "\"をcatch\n";
}
}
実行結果
xに読み込んだ値が1,7,99以外の時は例外は送出されません。
・1の時
まずint型の1が創出され、int型用の例外ﾊﾝﾄﾞﾗに補足され、『func:int型の例外』と表示します。これで例外に関する処理は終わりです。
・7の時
まずdouble型の7.0が創出され、double型用の例外ﾊﾝﾄﾞﾗに補足され、『func:double型の例外』と表示します。
さらに"Lucky seven!"という文字列の例外を送出します。
つまり、double型の例外を受け取った後に、const char*という別の型の例外として送出します。
・99の時
まず文字列型の"99例外"が創出されます。文字列(const char*型)用の例外ﾊﾝﾄﾞﾗに補足され、『func:文字列型の例外』と表示し、さらに受け取った例外をそのまま再送出します。
再送出された例外は、main関数中の文字列用の例外ﾊﾝﾄﾞﾗで補足され、『main:文字列"99例外"を補足』と表示されます。
このような動きを行う別のプログラムを書いてみます。
これはある特定の範囲に限定して整数をよみこむプログラムです。
#include <cctype>
#include <string>
#include <iostream>
using namespace std;
class FormatError {};
class ValueError {};
int string_to_int(const string& str)
{
int i = 0;
int no = 0;
while (isspace(str[i]))
i++;
switch (str[i]){
case '+' : i++;
}
while(i < str.length()){
if (!isdigit(str[i]))
throw FormatError();
no = no * 10 + (str[i] - '0');
i++;
}
}
int get_int()
{
int no = 0;
string temp;
try{
cin >> temp;
no = string_to_int(temp);
return no;
} catch (FormatError&){
cout << "数字以外の文字が入力されました。\n";
throw;
}
}
int get_int_bound(int low, int high)
{
int no = low;
try{
no = get_int();
if (no < low || no > high)
throw ValueError();
return no;
}catch (ValueError&){
cout << "不正な値が入力されました。\n";
throw;
}
}
int main()
{
try{
cout << "aの値："; int a = get_int();
cout << "bの値(10～99)："; int b = get_int_bound(10,99);
cout << "a + b =" << a + b << "\n";
} catch(...){
cout << "エラー発生!\n";
}
}
このﾌﾟﾛｸﾞﾗﾑでは数値の読み込み方を工夫しています。
たとえばint型の整数値を抽出子>> でcinから読み込もうとしているときに、アルファベトや記号文字などの文字が入力されたくないので、キーボードからの入力を文字列として読み込んで置き、それを解析して数値に変換するということをしています。
それでは各関数の説明に行きましょう。
・string_to_int
関数のget_intとget_int_boundから下請け的に呼び出される関数です。
仮引数strに受け取った文字列をint型の整数値に変換します。
ただし"13X"みたいに整数に見れない場合はFormatErrorを返します。
・get_int
キーボードからの入力をいったん文字列として読み込んで置き、string_to_intに依頼し、整数値に変換してからその値を返却する関数です。
FormatError例外を補足した場合は、「数字以外の文字が入力されました。」と表示します。表示後は例外を再送出します。
もしも再送出を行わなければ、本館数を呼び出したmain巻子では例外を補足できないです。（つまり、整数値を正しく読み込めたかどうかの判断が行えません。）
・get_int_bound
get_intと同様に、文字列として整数値を組み込んで返却する関数です。ただしｷｰﾎﾞｰﾄﾞから入力される数値がlow以上high以下(main関数の指示によって、10以上99以下)であることを期待して読み込む点が異なります。
読み込んだ整数が期待した範囲内でなければ、ValueError例外を送ります。
この関数は内部でget_intを呼び出していますが、そこからさらに関数string_to_intが呼び出されます。
仮想関数？？？
こんにちはぷないしんです。
今日は仮想関数
バーチャルな関数・・・のお話です。
前置きとして
せっかくなので以前使った”会員”のクラスに【シルバーメンバー】ｸﾗｽを追加していこうと思います。
一般会員ｸﾗｽとの差異は
・シニア特典でレベルによって内容の違うint形のデータメンバsenior_level
・上記のメンバの度合いを取得、設定するｹﾞｯﾀｰとｾｯﾀｰget_senior_level、set_care_level
それでは早速ヘッダとソースです。
silver.h
#ifndef ___SilverMember
#define ___SilverMember
#include <string>
#include "Member.h"
//シルバー会員クラス
class SilverMember : public Member{
int senior_level;
public:
//ｺﾝｽﾄﾗｸﾀ
SilverMember(const std::string& name, int no, double w, int level = 0);
//senior_levelのｹﾞｯﾀｰ
int get_senior_level() const { return senior_level; }
//senior_levelのｾｯﾀｰ
void set_senior_level (int level){
senior_level = (level >= 1 && level <= 5) ? level :0;
}
void print() const;
};
#endif
SilveMember.cpp
#include <string>
#include <iostream>
#include "silver.h"
using namespace std;
//ｺﾝｽﾄﾗｸﾀ
SilverMember::SilverMember(const string& name, int no, double w, int level)
:Member(name, no, w)
{
set_senior_level(level);
}
void SilverMember::print() const
{
cout << "No," << no() << ":" << name() << "(" << get_weight() << "kg)"
<< "Level =" << senior_level << "\n";
}
ｾｯﾀｰの動きによって、Levelの値は必ず0以上、5以下になります。
また、ﾒﾝﾊﾞ関数printは、そのレベルを表示します。
下の様にクラスによって表示項目が違います。
・No.1 Kimura Takuma is 46.5kg
↑一般クラス：会員番号、氏名、体重
・No.3 Kusanagi Takeshi is 58.5kg Special is Ippon Satisfaction
↑VIPクラス：会員番号、氏名、体重、特典
・No.2 Nakai Masamune is 59.7kg Level = 3
↑シルバークラス：会員番号、氏名、体重、レベル
VIPｸﾗｽと同じように、シルバークラスは一般クラスの派生なので構成としてはこんな感じですね。
Memberからpublic派生しているシルバー会員クラスは”一般クラスの一種”となります。
（is-Aの関係が成立するということです）
メンバ関数のいんぺい
基底クラスのMemberにﾒﾝﾊﾞ関数printが存在し、派生クラスであるVIPMember、SilverMemberにもこの関数があります。
この様に、基底クラスのメンバ関数と同じ名前のメンバ関数が派生先のクラスで定義されると、派生クラスのメンバ関数は基底ｸﾗｽのメンバ関数を隠します。
そのことを次のソースで確認してみましょう。
内容はVIPMember型、SilverMember型の各オブジェクトに対して、ﾒﾝﾊﾞ関数printを呼び出すだけの簡単なものです。
MemberPrint.cpp
#include <iostream>
#include "VIPMember0.h"
#include "silver.h"
using namespace std;
int main(){
Nakai.print();
}
kusanagiに対してはVIPMember::printが呼び出され、NakaiはSilverMember::printが呼び出されています。
この例では関数printの仮引数の型と個数は同一です。とまれ、関数名さえ同じなら仮引数の型や戸数が違っていても隠ぺいは行われます。
基底ｸﾗｽのﾒﾝﾊﾞ関数と同一名の派生ｸﾗｽのﾒﾝﾊﾞ関数は、仮引数の型や数が違っていても、基底ｸﾗｽのﾒﾝﾊﾞ関数を隠ぺいする。
VIPMemberとSilverMemberは、is-Aの関係であるpublic派生でMemberｸﾗｽから派生しています。
なので、Memberから継承したﾒﾝﾊﾞ関数printは、VIPMemberとSilverMemberでも公開ﾒﾝﾊﾞとして存在します。
継承したﾒﾝﾊﾞ関数は、名前が隠されているだけで会って、存在が消える訳ではありません。
実際に隠ぺいされている基底ｸﾗｽのﾒﾝﾊﾞ関数は、ｸﾗｽの外部から呼び出せます。
それを確認してみましょう。
Memberprint2.cpp
#include <iostream>
#include "VIPMember.h"
#include "silver.h"
using namespace std;
int main(){
Nakai.Member::print();
}
有効範囲解決演算子「：：」を使い、Member::print()により、基底クラスMemberのﾒﾝﾊﾞ関数printを呼び出しています。
基底ｸﾗｽから継承したﾒﾝﾊﾞと同名のﾒﾝﾊﾞが派生ｸﾗｽ内にある時、”基底ｸﾗｽ名：：ﾒﾝﾊﾞ名”で基底ｸﾗｽから継承した（隠ぺいされている）ﾒﾝﾊﾞにｱｸｾｽできる。
静的な型
次は下のｺｰﾄﾞです。
関数put_memberは、引数mに受け取った会員の情報を表示します。
その時、体重が55kg以上ならば先頭に@を付けます。
Memberprintref.cpp
#include <iostream>
#include "Member.h"
#include "VIPMember.h"
#include "silver.h"
using namespace std;
void put_member(const Member& m)
{
cout << (m.get_weight() >= 55 ? "@" : " ");
m.print();
}
int main(){
Member Kimura("Kimura Takuma", 1, 48);
put_member(Kimura);
put_member(Nakai);
}
関数put_memberが受け取るmの型は(constな)Member&型です。
main関数から三回呼び出している実引数は
・Member型kimura
・VIPMember型kusanagi
・SilverMember型Nakai
への参照です。
kusanagiへの実行結果から
①呼び出された関数put_memberの仮引数mがVIPMember型であるkusanagiを参照すること
②put_member宣言時でmに対して呼び出されるprintがVIPMember::printではなく、Member::printになっていること（特典が表示されていない）
が分かります。
①については、
基底ｸﾗｽへのﾎﾟｲﾝﾀ／参照は、派生ｸﾗｽのｵﾌﾞｼﾞｪｸﾄを指す／参照できるので不思議はありません。
②になる理由は単純でmの型が【Memberへの参照型】だからです。
基底ｸﾗｽへのﾎﾟｲﾝﾀ／参照が指す／参照する式を実行して得られるのは、派生ｸﾗｽの型ではなく、基底ｸﾗｽ型です。
つまり
ｵﾌﾞｼﾞｪｸﾄmの静的な型はMemberである
ということです。
静的な型の表示方法はtypeidを使えば出せるので確認してみましょう。
MemberStaticType.cpp
#include <iostream>
#include <typeinfo>
#include "Member.h"
#include "VIPMember.h"
#include "silver.h"
using namespace std;
int main(){
cout << typeid(*ptr).name() << "\n";
cout << typeid(ref).name() << "\n";
}
はい、ということでどちらもVIPMember型ではなく、Member型ですね。
仮想関数
ということで本題の仮想関数の話に入っていきます。
先ほどのままではさまざまな制約を受けます
この問題を解決する手段の一つして仮想関数を使います
では一般会員ｸﾗｽのヘッダ部分を改良していきましょう。
Member.h
//パンピーｸﾗｽ
#ifndef ___Member
#define ___Member
#include <string>
class Member{
std::string full_name;
int number;
double weight;
public:
//ｺﾝｽﾄﾗｸﾀ
Member(const std::string& name, int no, double w);
//名前
std::string name()const{
return full_name;
}
//番号
int no() const {
return number;
}
//体重返却
double get_weight() const {
return weight;
}
//体重設定
void set_weight(double w){
weight = (w > 0) ? w : 0;
}
//情報表示
virtual void print() const;
};
#endif
改良するといいながら前のﾍｯﾀﾞｰと違う所はprintの前にvirtualを追加したことだけです。
これでMemberPrintrfをｺﾝﾊﾟｲﾙ、実行してみましょう。
とまあこんな感じで特典情報やレベルが表示されました。
今までは呼び出される関数は、ﾌﾟﾛｸﾞﾗﾑをｺﾝﾊﾟｲﾙするときに静的に決定されていましたが、こうすることにより
mの参照先ｵﾌﾞｼﾞｪｸﾄのｸﾗｽに所属するﾒﾝﾊﾞ関数printの呼び出しで
基底ｸﾗｽであるMember形への参照mを通じて、Memberのﾒﾝﾊﾞ関数が呼び出されたり、派生クラスであるVipMemberやSeniorMemberのﾒﾝﾊﾞ関数が呼び出されています。
なので、当然mの参照先のｵﾌﾞｼﾞｪｸﾄがどのｸﾗｽであるのかはｺﾝﾊﾟｲﾙ時には決定できません。
そのため、どのｸﾗｽのﾒﾝﾊﾞ関数printを呼び出すのかはｺﾝﾊﾟｲﾙ時ではなく、ﾌﾟﾛｸﾞﾗﾑを実行したとき、動的に決定されます。
軽傷で済んだので継承していく
こんにちは、ぷないしんです。
昨日の記事を継承し、続きの話に入っていこうと思います。
昨日の記事の最後に
プログラム上のあちらこちらに”似て非なる”クラスが大量に存在し、開発効率、保守性が下がります。
と書きましたが、これらの問題を解決する手段として”派生”を使いましょう。
派生とは、既存ｸﾗｽの資産を継承するｸﾗｽを作り出すことです。
（派生の時は、ﾃﾞｰﾀﾒﾝﾊﾞ、ﾒﾝﾊﾞ関数などの資産を単純に継承するだけではなく、追加したり上書きしたりできる）
定義の仕方はこんな感じで
class base {
int a;
int b;
public:
void func(){ /*省略*/}
};
↓派生
class Derived : base {
int x;
public:
void method() {/*省略*/}
}
ｸﾗｽBaseと、それを継承するDerivedを定義しています。
ｸﾗｽDerivedを定義するときにｸﾗｽ名のDerivedの後ろに【：】、そのあとに継承元のbase
これでbaseから派生したｸﾗｽDerivedが出来ました。
呼び方としては
派生元
・基底ｸﾗｽ、上位ｸﾗｽ、親ｸﾗｽ、ｽｰﾊﾟｰｸﾗｽ
派生先
・派生ｸﾗｽ、下位ｸﾗｽ、、子ｸﾗｽ、ｻﾌﾞｸﾗｽ
等があるみたいで、C++では基底ｸﾗｽ、派生ｸﾗｽと呼ぶことが多いみたいですね。
さて、この二つのｸﾗｽが持つ資産を概略を表してみます。
この図のように、
・基底ｸﾗｽ base
【a】と【b】の二つの変数があり、関数は≪func≫の一つです。
・派生ｸﾗｽDerived
定義を行っているときは【x】と≪method≫だけが宣言、定義されています。
ですが、baseを継承しているのでそれら二つを合わせ変数は3個、関数は２個になります。
派生ｸﾗｽは基底ｸﾗｽの資産を継承すると同時に、それを部分として含むｸﾗｽの事である。
（ちなみにｺﾝﾊﾟｲﾗによって自動的に定義されるﾃﾞﾌｫﾙﾄｺﾝｽﾄﾗｸﾀとﾃﾞﾌｫﾙﾄﾃﾞｽﾄﾗｸﾀ、代入演算子なども、各ｸﾗｽの資源として含まれる、またﾌﾚﾝﾄﾞ関係は継承されることはない）
クラス階層図
派生ｸﾗｽは基底ｸﾗｽの”子供”のようなもので、その親子関係を表してみます。
派生ｸﾗｽDerivedの定義"：base"の部分は
「私の親はｸﾗｽbaseです」
という宣言です。
つまり、親ｸﾗｽ"base"の知らないところで子供が生まれています。
子供は親を知っているのですが、親は子供を知りません。
親として、子供がいるのか、いないのか、もしいるのなら何人いるのかといった情報を親は持ちえません。
基底ｸﾗｽの方で『○○ｸﾗｽを私の子供にします』といった宣言はできないのです。
なので、矢印の向きは派生ｸﾗｽ→基底ｸﾗｽになります。
ところで、派生は一度だけではなく、何度でも出来ます。
class A{
//省略
};
class B : A{
//省略
};
class C : B{
//省略
};
class D : B{
//省略
};
ｸﾗｽAからｸﾗｽBが派生し、ｸﾗｽBからｸﾗｽC、ｸﾗｽDが派生しています。
ｸﾗｽBはｸﾗｽAの子で、ｸﾗｽC、DはｸﾗｽBの子です。
つまり、ｸﾗｽC、DはｸﾗｽAの孫ですね。
一部では直接の親にあたるｸﾗｽを直接基底ｸﾗｽと呼び、直接の親ではないが、先祖になるｸﾗｽを間接基底ｸﾗｽとよぶこともあるみたいです。
ｸﾗｽD視点でみると、ｸﾗｽBは直接基底ｸﾗｽで、ｸﾗｽAは間接基底ｸﾗｽになるといった具合です。
また、「ｸﾗｽDはｸﾗｽAから間接派生している／ｸﾗｽBから直接派生している」といった呼ばれかたをすることもあります。
派生の形態
外部に公開したほうがいいﾃﾞｰﾀや手続きのみを公開し、そうでないものを非公開とするのがｸﾗｽ設計時の原則です。
派生ｸﾗｽは基底ｸﾗｽの資産を継承するが、それらをｸﾗｽ外部に公開するかどうかは別問題です。
基底ｸﾗｽと派生ｸﾗｽ内のﾒﾝﾊﾞのｱｸｾｽ関係はこの三種類の派生形態によって変わります。
・private派生
・protected派生
・public派生
これら指定の仕方は派生ｸﾗｽを定義するときに、基底ｸﾗｽ名の前にｱｸｾｽ指定子を書いて行います。
例えばこの様に書いた場合はpublic派生です。
class Derived : public Base {}:
また、ｱｸｾｽ指定子を省略したときは、自動的に【private派生】になります。
（派生ｸﾗｽを定義する時のｷｰﾜｰﾄﾞがstructの時は【public派生】になる）
三つの派生形態の例としてですが
#ifndef ___Super
#define ___Super
class Super{
private:
int pri;
protected:
int pro;
public:
int pub;
};
#endif
private派生
ｸﾗｽSuperからprivate派生を行う例です
Private.cpp
#include "Super.h"
class Sub : private Super {
void f(){
// pri = 1;
pro = 2;
pub = 3;
}
};
int main()
{
Sub x;
// x.pri = 5;
// x.pro = 6;
// x.pub = 7;
}
（ｺﾝﾊﾟｲﾙｴﾗｰになるところはｺﾒﾝﾄｱｳﾄ済み）
実行しても何も起きないﾌﾟﾛｸﾞﾗﾑです。
private派生を行うと、派生ｸﾗｽSubにとってｸﾗｽSuperは非公開の基底ｸﾗｽになります。
ｱｸｾｽ性は以下の通りです。
派生ｸﾗｽの内部からは基底ｸﾗｽの【privateﾒﾝﾊﾞ】はｱｸｾｽ出来ません。
また、基底ｸﾗｽの【protectedﾒﾝﾊﾞ】と【publicﾒﾝﾊﾞ】は派生ｸﾗｽ内では【privateﾒﾝﾊﾞ】として扱われ、派生ｸﾗｽの利用者に公開されません。
ｺﾒﾝﾄｱｳﾄした部分がｺﾝﾊﾟｲﾙｴﾗｰになり理由ですが
①派生ｸﾗｽsubの内部において、基底ｸﾗｽSuperの【privateﾒﾝﾊﾞ】priのｱｸｾｽは出来ない。
②基底ｸﾗｽsuperの全ﾒﾝﾊﾞは、派生ｸﾗｽsubの利用者に対して非公開である。
限定公開（protected)ﾒﾝﾊﾞは外部に対して存在を隠すが、直接派生ｸﾗｽに対しては存在を隠さない
という事です。
protected派生
ｸﾗｽSuperからprotected派生を行う例です。
protected.cpp
#include "Super.h"
class Sub : protected Super {
void f(){
// pri = 1;
pro = 2;
pub = 3;
}
};
int main()
{
Sub x;
// x.pri = 5;
// x.pro = 6;
// x.pub = 7;
}
（ｺﾝﾊﾟｲﾙｴﾗｰになるところはｺﾒﾝﾄｱｳﾄ済み）
ｱｸｾｽ性は以下の通りです。
派生ｸﾗｽのﾒﾝﾊﾞ関数から基底ｸﾗｽの【privateﾒﾝﾊﾞ】をｱｸｾｽ出来ないのはprivate派生と同じです。
ただ、基底ｸﾗｽの【protectedﾒﾝﾊﾞ】と【publicﾒﾝﾊﾞ】が派生ｸﾗｽ内で【protectedﾒﾝﾊﾞ】として扱われる点がprivate派生と違う所です。
（これらのﾒﾝﾊﾞは派生ｸﾗｽの利用者に対しては非公開）
protectedﾒﾝﾊﾞはSubから派生したｸﾗｽの内部ではｱｸｾｽ出来ますが、その外部からは不可能です。
public派生
ｸﾗｽSuperからpublic派生を行う例です。
public.cpp
#include "Super.h"
class Sub : public Super {
void f(){
// pri = 1;
pro = 2;
pub = 3;
}
};
int main()
{
Sub x;
// x.pri = 5;
// x.pro = 6;
x.pub = 7;
}
(ｺﾝﾊﾟｲﾙｴﾗｰになるところはｺﾒﾝﾄｱｳﾄ済）
ｱｸｾｽ性はこちらです
他の派生と同様に、派生ｸﾗｽのﾒﾝﾊﾞ関数から基底ｸﾗｽの【privateﾒﾝﾊﾞ】をｱｸｾｽするのは出来ません。
基底ｸﾗｽの【protectedﾒﾝﾊﾞ】は派生ｸﾗｽ中でも【protectedﾒﾝﾊﾞ】としての扱いで、基底ｸﾗｽの【publicﾒﾝﾊﾞ】は派生ｸﾗｽでも【publicﾒﾝﾊﾞ】として扱われるので、派生ｸﾗｽの利用者に公開されます。
つまり、基底ｸﾗｽのprivate以外のﾒﾝﾊﾞ（protected、public）のｱｸｾｽ性が派生ｸﾗｽでも維持されています。
派生のカタチ
三種類の派生（private、protected、public）に共通する原理や規則性を纏めると
・どの派生でも基底ｸﾗｽの非公開（private)ﾒﾝﾊﾞは派生ｸﾗｽからはｱｸｾｽできない
・”〇〇派生”を行うと、基底ｸﾗｽの公開(public)ﾒﾝﾊﾞが派生ｸﾗｽの”○○部”に所属するようになる
・限定公開(protected)ﾒﾝﾊﾞは外部には公開されないが自分の子（直接派生するｸﾗｽ）には公開される
こんなところでしょうか。
以上がｸﾗｽの継承の話でした。
協力者のキムラ、クサナギ（敬称略）に感謝をしつつ本日はこのあたりにしておきます。
ありがとうございました。
ぷないしん
クラスでケガしたけど軽傷ですんだ
こんにちはぷないしんです。
タイトルに深い意味はありません。
C++の大きな特徴であるクラス、今日はその継承について今一度振り返ってみます。
という事でよく説明や試験問題で使われる”会員”クラスを作っていき、例によってそれらを解説、改良していきながらやっていきます。
ではまずﾍｯﾀﾞｰから
Member.h
//パンピーｸﾗｽ
#ifndef ___Member
#define ___Member
class Member{
std::string full_name;
int number;
double weight;
public:
//ｺﾝｽﾄﾗｸﾀ
Member(const std::string& name, int no, double w);
//名前
std::string name()const{
return full_name;
}
//番号
int no() const {
return number;
}
//体重返却
double get_weight() const {
return weight;
}
//体重設定
void set_weight(double w){
weight = (W > 0) ? w : 0;
}
//情報表示
void print() const;
#endif
このｸﾗｽのﾃﾞｰﾀﾒﾝﾊﾞは下の三つです・
・名前”full_name”
・会員番号"number"
・体重"weight"
ｺﾝｽﾄﾗｸﾀは【name】【no】【w】に受け取った三つの値でそれぞれのﾒﾝﾊﾞを初期化します。
ｺﾝｽﾄﾗｸﾀの他、5つのﾒﾝﾊﾞ関数が定義されています。
それぞれ
名前を取得する【name】 会員番号を取得する【no】体重を取得する【get_weight】、また設定を行う【set_weight】、会員情報を表示する【print】
ですね。
つづいてこちらを
Member.cpp
#include <iostream>
#include "Member.h"
using namespace std;
//ｺﾝｽﾄﾗｸﾀ
Member::Member(const string& name, int no, double w)
: full_name(name),number(no){
set_weight(w);
}
//情報表示
void Member::print() const{
cout << "No" << number << ":" << full_name << "(" << weight << "kg)\n";
}
体重（ﾒﾝﾊﾞのweight）を設定するﾒﾝﾊﾞ関数のset_weightはweightがマイナスにならないように調整（もしwにマイナスを受けとった場合、weightに0を入れる）
ｺﾝｽﾄﾗｸﾀの
set_weight(w);
部分はset_weightに体重の設定を任せています。
また、氏名のfull_nameと番号のnumberの初期化はｺﾝｽﾄﾗｸﾀの初期化子で行っています。↓
full_name(name),number(no)
では、Member型のｵﾌﾞｼﾞｪｸﾄを一つ作り、各ｹﾞｯﾀｰを呼び出すだけの簡単なものを書いていきます。
Membertest.cpp
#include <iostream>
#include "Member.h"
using namespace std;
int main(){
Member kimura("Kimura Takuma", 1, 48);
double weight = kimura.get_weight(); //キムラの体重
kimura.set_weight(weight - 1.5); //キムラが減量(-1.5kg)
cout << "No:" << kimura.no() << " " <<kimura.name() << " is " << kimura.get_weight() << "kg\n";
}
ここではパンピーのキムラ君を表しているのがMember型のｵﾌﾞｼﾞｪｸﾄkimuraです。
キムラ君の会員番号は1で、体重は48kg、ところが、キムラ君は1.5kgのダイエットを成功したのでget_weightとset_weightを使い、体重を46.5kgに更新してます。
VIP会員クラス
さて、このクラブは特典を付けた【VIP会員】制度が出来ました。
会員ごとに内容が違う特典をstring型のﾒﾝﾊﾞで表す【VIPｸﾗｽ】を作ります。
パンピーｸﾗｽMemberを元に、VIPｸﾗｽを作るのは簡単ですね。
ﾍｯﾀﾞｰとｿｰｽの各ﾌｧｲﾙをｺﾋﾟｰし、部分的な追加と変更をするだけです。
この方法で作った”試作版”のVIPｸﾗｽのﾍｯﾀﾞｰとｿｰｽ部を作ります。
VIPMember0.h
//VIPｸﾗｽ
#ifndef ___VIPMember0
#define ___VIPMember0
#include <string>
class VIPMember0{
std::string full_name;
int number;
double weight;
std::string special;
public:
//ｺﾝｽﾄﾗｸﾀ
VIPMember0(const std::string& name, int no, double w, const std::string& spe);
//名前
std::string name()const{
return full_name;
}
//番号
int no() const {
return number;
}
//体重返却
double get_weight() const {
return weight;
}
//体重設定
void set_weight(double w){
weight = (w > 0) ? w : 0;
}
//情報表示
void print() const;
//特典
std::string get_special() const {return special;}
//特典設定
void set_special(const std::string& spe){
special = (spe != "") ? spe : "Unregistered";
}
};
#endif
特典のstring型のﾃﾞｰﾀﾒﾝﾊﾞspecialを作ると同時に、特典の取得と設定をするget_special、set_specialを追加しました
（specialのセッターset_specialは、もし仮引数に空文字を受け取ったとき、文字列"Unregistered"をspecialに代入するようにしています）
それとMember.cppの方も手を入れていきましょう。
VIPMember0.cpp
#include <iostream>
#include <string>
#include "VIPMember0.h"
using namespace std;
//ｺﾝｽﾄﾗｸﾀ
VIPMember0::VIPMember0(const string& name, int no, double w, const string& spe)
: full_name(name),number(no){
set_weight(w);
set_special(spe);
}
//情報表示
void VIPMember0::print() const{
cout << "No" << number << ":" << full_name << "(" << weight << "kg)\n"
<< "Special =" << special << "\n";
}
ｺﾝｽﾄﾗｸﾀの仕様も変えています
特典用の文字を受け取る仮引数【spe】が増えると同時に、その値の設定を処理するところを追加しています。
(ﾒﾝﾊﾞ【special】の値設定はメンバ関数の【set_special】に任せているので、仮引数【spe】に空文字を受け取った時、【special】には"Unregistered"が表示される）
そして、これらを利用する実装部です。
VIPMember0test.cpp
#include <iostream>
#include "VIPMember0.h"
using namespace std;
int main(){
cout << "No:" << Kusanagi.no() << " " <<Kusanagi.name() << " is " << Kusanagi.get_weight() << "kg\n"
}
はい
VIP会員のクサナギタケシ君を表しているのが、クラスVIPMember0型のｵﾌﾞｼﾞｪｸﾄであるKusanagiです。
会員番号は3番で、体重は60kgからダイエットに成功し58.5kg、特典は一本サティスファクションです。
さて、この一般会員ｸﾗｽとVIPｸﾗｽを両方を使うプログラムを書いてみます。
Wtest.cpp
#include <iostream>
#include "Member.h"
#include "VIPMember0.h"
using namespace std;
//パンピーダイエット(体重をdw減らす)
void diet(Member& m, double dw){
double weight = m.get_weight();
if (weight > dw) m.set_weight(weight - dw);
}
//VIPダイエット（体重をdw減らす）
void diet(VIPMember0& m, double dw){
double weight = m.get_weight();
if (weight > dw) m.set_weight(weight - dw);
}
int main(){
Member Kimura("Kimura Takuma", 1, 48);
diet(Kimura,0.3); //キムラが0.3kgダイエット
cout << "No:" << Kimura.no() << " " <<Kimura.name() << " is " << Kimura.get_weight() << "kg\n";
cout << "No:" << Kusanagi.no() << " " <<Kusanagi.name() << " is " << Kusanagi.get_weight() << "kg\n"
}
二つのdiet関数は会員のﾀﾞｲｴｯﾄ処理を行う関数です。
同じ処理をしている関数が各ｸﾗｽ毎に作られ、多重定義をしています。
なぜかというと、関数の処理を行う対象の変数の”型”が違うからです。
（この関数の違いは、引数"m"の型だけで、その他は全部同じ）
一般ｸﾗｽとVIPｸﾗｽの見た目は殆ど同じなのですが、ｺﾝﾊﾟｲﾗ視点で見ると、何の関係もないｸﾗｽです。
同一、または似たようなｸﾗｽを仕様の違うｸﾗｽとして書いてしまうと、
プログラム上のあちらこちらに”似て非なる”クラスが大量に存在し、開発効率、保守性が下がります。
そしてこの話を継承して明日へ…
ぷないしん。
メモリの記憶域の話～ﾃﾞｽﾄﾗｸﾀを添えて～
こんにちはぷないしんです。
今日はｸﾗｽの外側のメモリ管理の話をします。
あとちょっぴりﾃﾞｽﾄﾗｸﾀの話も
ということで、まずは配列ｸﾗｽを使ってｸﾗｽの外側の資源の管理方法です。
整数型の配列を実現するｸﾗｽを記述します。
IntArray.h
//整数型配列ｸﾗｽ
#ifndef ___Class_IntArray
#define ___Class_IntArray
class IntArray{
int nelem;
int* vec;
public:
//ｺﾝｽﾄﾗｸﾀ
IntArray(int size) : nelem(size){
vec = new int[nelem];
}
//要素の数を返却
int size() const {
return nelem;
}
//演算子
int& operator(int i){
return vec[i];
}
};
#endif
このｸﾗｽのﾃﾞｰﾀﾒﾝﾊﾞｰは要素の数であるnelemと、配列の先頭の要素を指すﾎﾟｲﾝﾀであるvecの二つです。
要素の数であるnelemの値は、ﾒﾝﾊﾞ関数のsizeで調べられます。
では、コンストラクタとこの関数についてお話します。
ｺﾝｽﾄﾗｸﾀ
IntArray(int size) : nelem(size){
vec = new int[nelem];
}
コンストラクタ本体では、メモリの領域を確保し、配列の本体を動的に作ります。
生成する配列の要素の数は、仮引数であるsizeで受け取った値です。
ｵﾌﾞｼﾞｪｸﾄが下の様に定義されたときのｺﾝｽﾄﾗｸﾀの動作ですが
intArray x(5);
まず、nelem(size)の働きで、ﾃﾞｰﾀﾒﾝﾊﾞｰnelemが5で初期化されます。
次に実行されるｺﾝｽﾄﾗｸﾀではnew演算子で確保したnelem個分、記憶域の先頭要素へのポインタをvecに代入します。
実際に確保しているメモリ域は生成したｵﾌﾞｼﾞｪｸﾄxの外側にあります。
にもかかわらず、ｸﾗｽIntaArrayの内部からvec[0]、vec[1]、～～～、vec[4]の式で生成した配列の各要素を先頭から順番でアクセス可能です。
添字演算子
配列の各要素に外部から簡単にアクセスできるように定義しているのが""
どこかの地域では添字演算子とか呼ぶらしいですね。
その演算子関数operatorの返却値の型はなんとint&です。
なぜなら
a = x[5]
(代入演算子の右側はintでもint&でもOK）
代入の右辺のみで使用するならintでも大丈夫なのですが、下の様に左辺における様にするには、int&じゃないとできないからです。
x[2] = 5
(代入演算子の左側はintではNG、int&を使おう)
それでは実際にIntArrayを動かしてみましょう。
//整数型配列ｸﾗｽを使う
#include <iostream>
#include "IntArray.h"
using namespace std;
int main()
{
int n;
cout << "Select the number of elements:";
cin >> n;
IntArray x(n);
for (int i = 0; i < x.size(); i++)
x[i] = i;
for (int i = 0; i < x.size(); i++)
cout << "x[" << i << "] =" << x[i] << "\n";
}
n個分の配列を作り、すべての要素に添字と同じ値を代入ついでに表示しています。
ではここで下の関数についてちょっと考えてみましょう。
void func(){
IntArray x(5);
～省略～
}
IntArray型のｵﾌﾞｼﾞｪｸﾄxは関数内で生成されているので自動的にメモリ域の期間が与えられます。
それがいつまで有効なのかというと、
①二つのﾒﾝﾊﾞ"nelem"と"vec"を持つｵﾌﾞｼﾞｪｸﾄ"x"を生成
②ｺﾝｽﾄﾗｸﾀでxを初期化
（nelemが5で初期化、そのあと5個の配列用のメモリ域がnew演算子で確保、先頭要素へのﾎﾟｲﾝﾀがvecに代入）
③関数funcの実行終了、自動的にメモリ域の期間を持っているｵﾌﾞｼﾞｪｸﾄ"xこの期間が終了し、破棄される。
だが、new演算子で確保された配列本体用のメモリ域は破棄されることなくメモリ域に残った状態になる。
ｺﾝｽﾄﾗｸﾀで確保した動的な記憶期間をもつメモリ域は、ｵﾌﾞｼﾞｪｸﾄを破棄したとしても、自動的に解放されることはありません。
解放されていない配列はどこからも指定されていない、無駄な領域としてメモリ上に取り残されます。
なのでこの関数を何度も読みだすと、その都度無駄な領域が確保されていき、実際に使えるメモリ域が減っていきます。
我々がこの期間をコントロールできるｵﾌﾞｼﾞｪｸﾄは好きな時に生成し、好きな時に破棄できるのですが、その作業をちゃんと行うのが我々の使命です。
なのでこのように確保したｵﾌﾞｼﾞｪｸﾄはちゃんと指示して解放しないといけないです。
そのために、配列本体の領域を破棄する【ﾒﾝﾊﾞ関数】を定義しましょう。
void IntArray::delete_vec(){
delete vec;
}
こんな感じです。
この関数を呼び出すように上の関数を書き換えます。
void func(){
IntArray x(5);
//～省略～
x.delete_vec();
}
これでXが破棄される前に配列本体を破棄できます。
しかしこの方法は微妙ですね。
・delete_vec()を呼び出し忘れる。
・ｵﾌﾞｼﾞｪｸﾄを使う前に間違えてdelete_vec()呼び出してしまう。
ということをやりかねないからです。
ｵﾌﾞｼﾞｪｸﾄの外側の資源を管理する場合は、確保と破棄の管理を徹底しましょう。
という事でIntArrayを改良していきます。
NewIntArray.h
//整数型配列ｸﾗｽ
#ifndef ___Class_IntArray
#define ___Class_IntArray
class IntArray{
int nelem;
int* vec;
public:
//ｺﾝｽﾄﾗｸﾀ
explicit IntArray(int size) : nelem(size){
vec = new int[nelem];
}
//ﾃﾞｽﾄﾗｸﾀ
-IntArray() {delete vec;}
//要素の数を返却
int size() const {return nelem;}
//演算子
int& operator(int i){return vec[i];}
};
#endif
ｺﾝｽﾄﾗｸﾀを定義するときにexplicitを追加しました、これは宣言するｺﾝｽﾄﾗｸﾀを明示的ｺﾝｽﾄﾗｸﾀにするための関数指定子です。
そも、明示的ｺﾝｽﾄﾗｸﾀとは暗黙的に行う型変換を抑止するｺﾝｽﾄﾗｸﾀです。
具体例としては
①IntAry a = 5;
(最初のｸﾗｽなら大丈夫、このｸﾗｽではNG)
②IntAry b(5);
(どちらでも大丈夫)
ｺﾝｽﾄﾗｸﾀにexplicitの指定がない最初のｸﾗｽではどちらでも可能です。
ですが今回のｸﾗｽでは①の記述をするとｺﾝﾊﾟｲﾙｴﾗｰを吐きます。
①の宣言方法は”配列を整数で初期化している”と誤解を生むかもしれません、その紛らわしい初期化をexplicitは抑止してくれます。
引数が単一のｺﾝｽﾄﾗｸﾀが”＝”形式で起動されるのを防ぐにはexplicitを与えて定義しよう！
デストラクタ
このｸﾗｽで新しく追加された
-IntArray() {delete[] vec;}
この記述はﾃﾞｽﾄﾗｸﾀと呼ばれる特殊なﾒﾝﾊﾞ関数です。
クラス名の前に”-”がついた名前のこの関数は
そのクラスのｵﾌﾞｼﾞｪｸﾄが破棄されそうになった時に自動的に呼び出されます。
なので、ｺﾝｽﾄﾗｸﾀと対照的な存在ですね。
ｵﾌﾞｼﾞｪｸﾄ生成時に呼び出されるﾒﾝﾊﾞ関数がｺﾝｽﾄﾗｸﾀ、それとは逆でｵﾌﾞｼﾞｪｸﾄが破棄される時に呼び出されるﾒﾝﾊﾞ関数がﾃﾞｽﾄﾗｸﾀ
ﾃﾞｽﾄﾗｸﾀはｺﾝｽﾄﾗｸﾀと同じで返却値をもっていません、ただ自動的に呼び出される性質上、ｺﾝｽﾄﾗｸﾀと違い引数は受け取りません。
このｸﾗｽのﾃﾞｽﾄﾗｸﾀはｵﾌﾞｼﾞｪｸﾄ外部のメモリ域解放を行います（ﾎﾟｲﾝﾀvecが示す配列の領域）
これなら上記のfunc関数を利用した時にﾃﾞｽﾄﾗｸﾀがvecが指す領域を解放してくれます。
こんな感じです。
まとめとしては
・ｺﾝｽﾄﾗｸﾀで確保したメモリ域などのｵﾌﾞｼﾞｪｸﾄの外側の資源の解放処理はデストラクタで実行しよう！！
・ｵﾌﾞｼﾞｪｸﾄが外部の資源を管理するようなｸﾗｽは、資源を獲得時に初期化を行おう！
以上、メモリ領域とデストラクタの話でした。
ありがとうございます。
ぷないしん
変換関数や演算子関数について
こんにちは、ぷないしんです。
昨日のｶｳﾝﾀｰｸﾗｽを作成するにあたってサラっと変換関数や演算子関数などとのたまっていましたが、今日はもう少し掘り下げていきたいと思います。
最初に昨日のﾍｯﾀﾞｰﾌｧｲﾙを張っておきます
NewCounter.h
//カウンタクラス
#ifndef ___Class_Counter
#define ___Class_Counter
#include <limits>
class Counter{
unsigned cnt; //ｶｳﾝﾀ
public:
//ｺﾝｽﾄﾗｸﾀ ｶｳﾝﾀを0に
Counter() : cnt(0){}
//unsigned型へ変換する
operator unsigned() const {
return cnt;
}
//論理否定演算子!
bool operator!() const {
return cnt == 0;
}
//前置増分演算子++
Counter& operator++(){
if (cnt < std::numeric_limits<unsigned>::max()) cnt++;
return *this;
}
//後置増分演算子++
Counter operator++(int){
Counter x = *this;
++(*this);
return x;
}
//前置減分演算子--
Counter& operator--(){
if (cnt > 0) cnt--;
return *this;
}
//後置減分演算子--
Counter operator--(int){
Counter x = *this;
--(*this);
return x;
}
};
#endif
まず変換関数とは
特定の型の値を生成して返すメンバ関数のことで、例えば"Type型への変換関数"とは下のような名前のメンバ関数と定義しています。
operator Type
(Type型への変換関数の関数名）
前回のｶｳﾝﾀｸﾗｽで使用していたのはunsigned型への変換関数で、関数名としては
"operator unsigned"になり、定義としては次のようにします。
operator unsigned() const { return cnt;}
関数名として"operator unsigned"は二つの単語を使い構成しています。
というのも関数名それ自体が返却値の型を表しているからで、返却値の型を指定することはできないし、引数を受け取る事もできません。
（変換関数は基本的にconstで実現する）
この変換関数"operator unsigned"を使えばCounterからunsignedへ型を変換する時、明示的にも暗黙的にもキャストできるというわけです。
ソースとしては次のような感じですね。
unsigned x;
Counter cnt;
～省略～
x = unsigned(cnt);
x = (unsigned)cnt;
x = static_cast<unsigned>(cnt);
x = cnt;
一番下は暗黙的キャストで上3つは明示的キャストです。
このどれもがcntのｶｳﾝﾀをunsigned型の整数値として取り出します。
実はこれ、組み込み型で行う型変換と同じ形ですね。
int i;
double a;
～省略～
a = double(i);
a = (double)i;
a = static_cast<double>(i);
a = i;
これは分かりやすいし使いやすい。
ちなみに、変換関数"operator unsigned"はCounterｸﾗｽのﾒﾝﾊﾞ関数でもあるのでﾄﾞｯﾄ演算子を使って呼び出すことも可能です。
x = cnt.operator unsigned();
こんな感じですね
でも長くなるだけで特に便利でもないのでこの形で使うことは普通は無いでしょう。
まとめると、
ｵﾌﾞｼﾞｪｸﾄをType型に変換する必要が多いなら、Type型へ変換するoperator Typeを変換関数として定義すると便利ということですね。
演算子関数
次に演算子関数についてですが、これも変換関数と同じで演算子関数の定義の仕方も簡単です。
例えば”💩演算子”は下の名前の関数として定義をします。
operator 💩
演算子関数"operator 💩"を定義するとクラス型ｵﾌﾞｼﾞｪｸﾄにてその💩演算子使えるようになります。
Counterｸﾗｽで定義した三つの演算子（!、++、--）を見ていきましょう。
論理否定演算子!
初めに”！”演算子から見ていきます。
Counterｸﾗｽではｶｳﾝﾀの値が0かどうかを判定するという内容で定義します
関数名としては"operator !"で下の様に書きます。
bool operator! () const { return cnt == 0;}
("operator !"も二つの単語で構成されているがoperatorと"!"の間にｽﾍﾟｰｽを入れても大丈夫！）
この関数はｶｳﾝﾀの値が0であればtrue、そうでなければfalseを返します。
ということはC++の標準である！演算子と同じ仕様になりましたね。
なのでこの様に利用できてしまいます。
if (!cnt) 動作
(cntが0であれば動作を実行)
これなら使い方をいちいち覚える必要ないので非常に便利ですね。
ポイントとしては演算子関数を定義するときは、その演算子の本来の仕様と出来る限り同じか類似した仕様になるように注意しましょう！
増分演算子、減分演算子
ｸﾗｽに対してこれらを定義する際は前置きと後置きを区別しましょう。
下がよくある宣言形式です。
class C{
～省略～
public:
Type operator++();
Type operator++(int);
}
前置の時は引数を受け取らない形で、後置はint形の引数を受け取る形です。
また、各関数の返却値型Typeは任意なのですが、一応
前置は C&型
後置は C型
これで組み込み型で使う++と同じ仕様になります。
両者の違いとしては
・前置（++💩)は左辺値式（代入の左辺にも右辺にも置ける式）
・後置（💩++)は右辺値式（代入の右辺にしか置けない式）
Counterｸﾗｽの前置++演算子を定義するときはこんな感じです。
Counter& operator++(){
if (cnt < std::numeric_limits<unsigned>::max()) cnt++;
return *this;
}
ｲﾝｸﾘをした後＜自分＞へ参照を返すために*thisによる返却をしています。
（ｸﾗｽCの前置の増分/減分演算子はその呼び出しするときの式が左辺値式にするため、C&型の*thisを返すように定義する）
Counterｸﾗｽの後置++演算子を定義するときはこんな感じです。
Counter operator++(int){
Counter x = *this;
if (cnt < std::numeric_limits<unsigned>::max()) cnt++;
return x;
}
ｲﾝｸﾘをする前の値を返す必要があるので、前置のときより手順が複雑です
①自分自身の*thisのｺﾋﾟｰを作業用変数xに一時保存
②ｶｳﾝﾀをｲﾝｸﾘ
③関数から抜け出るとき、保存しておいたｲﾝｸﾘ前のxを返却
と、こんな感じで後置きの場合はいったん*thisをｺﾋﾟｰしておき、そのｺﾋﾟｰを返却する流れですね。
（ｸﾗｽCの後置の増分/減分演算子はｲﾝｸﾘ/ﾃﾞｸﾘ前の自身の値を返却するように定義しよう）
また前置、後置を比較したところ
++、--の演算子関数は前置より後置の方がｺｽﾄ的に高くなるかもしれないので、前置でも後置でもどちらでもよい場合は前置の方を使ったほうがいいですね。
ところで、この前置も後置も
if (cnt < std::numeric_limits<unsigned>::max()) cnt++;
のところは同じですね。
同じソースならこの部分を呼び出せば重複を解消できます。
だから上記のソースでは
Counter operator++(int){
Counter x = *this;
++(*this);
return x;
}
と表すことが出来ますね。
最後に、これら定義した演算子関数をｸﾗｽのｵﾌﾞｼﾞｪｸﾄで適用することは、ﾒﾝﾊﾞ関数の演算子関数を呼び出していることと同義です、つまり下の様に解釈できます。
++x → x.operator++()
前置（引数無し）
x++ → x.operator++(0)
後置(ﾀﾞﾐｰの引数が渡される）
規定により、後置きの場合はﾀﾞﾐｰの値として0が渡されます。
また一応こいつらも変換関数と同じで下の様に表せますが読みにくくなるだけで使いませんね。
x.operator++()
(前置を呼び出す++xと同じ）
x.operator++(0)
(後置を呼び出すx++と同じ）
以上、変換関数と演算子関数でした。
これらを組み合わせて昨日のｶｳﾝﾀｸﾗｽを書いているのでぜひもう一度見てみてください。
ありがとうございました。
ぷないしん。
C++実践編（カウンタークラスを作成する）
こんにちは、ぷないしんです。
昨日の関数の渡し方の詳しい話はまた今度にして今日は、C++のクラスを作成していきたいと思います。
今回作成するのはズバリ
【カウンタークラス】
内容としては
・0~9の1桁の整数値を数え上げる
・初期化、生成すると同時にカウンタを0にする。
・カウントアップ（値をインクリ）
・カウントダウン（値をデクリ）
・カウンタの値を調べる
今回のクラスは小規模なのですべてのメンバ関数をインライン関数にし、ヘッダだけで実現してみます。
ということでさっそくコードを記述します。
【counter.h】
//カウンタクラス
#ifndef ___Class_Counter
#define ___Class_Counter
#include <limits>
class Counter{
unsigned cnt; //ｶｳﾝﾀ
public:
//ｺﾝｽﾄﾗｸﾀ ｶｳﾝﾀを0に
Counter() : cnt(0){}
//ｶｳﾝﾄｱｯﾌﾟ (ｶｳﾝﾀの上限はunsigned型の最大値になる)
void increment(){
if (cnt < std::numeric_limits<unsigned>::max()) cnt++;
}
//ｶｳﾝﾄﾀﾞｳﾝ(ｶｳﾝﾀの加減は0)
void decrement(){
if (cnt > 0) cnt--;
}
//ｶｳﾝﾀの返却(cntのｹﾞｯﾀｰ)
return cnt;
}
};
#endif
ｶｳﾝﾀを格納しているのが非公開のﾃﾞｰﾀﾒﾝﾊﾞcnt
型はunsigned
すなわち、ｶｳﾝﾀとして表現できる数値はunsigned型で使える範囲と同じです。
ということは加減が0で上限がnumeric_limits<unsigned>::max()になります。
numeric_limits<unsigned>::max()
について
まずunsigned型についてのおさらいですが、unsigned型とは
2バイトまた4バイトの符号なし整数の値を記憶できる型です。
次にnumeric_limitsですがこれはまず最初に<limits>ヘッダーをインクルードした時に使える標準ライブラリで::maxを使用すればその直前に指定した型の最大値を取得できます。
なので今回はunsigned型の最大値を取得するクラスととりあえず理解しておきます。
次に各メンバ関数の解説をしておくと
・ｺﾝｽﾄﾗｸﾀ ｶｳﾝﾀの値を0にしています。
・increment関数 if文でｶｳﾝﾀの値が最大値より小さい時、ｶｳﾝﾀの値をｲﾝｸﾘﾒﾝﾄします。
・decrement関数 if文でｶｳﾝﾀの値が0より大きい時、ｶｳﾝﾀの値をﾃﾞｸﾘﾒﾝﾄします。
・value関数 ｶｳﾝﾀの値を返却しています。
それではCounterｸﾗｽを実際に利用してみましょう。
#include <iostream>
#include "Counter.h"
using namespace std;
int main()
{
int no;
Counter x;
cout << "Count up count:";
cin >> no;
for (int i = 0; i < no; i++){
x.increment(); //Count up
}
cout << "Count down count:";
cin >> no;
for (int i = 0; i < no; i++){
x.decrement();
}
}
まず最初に、CounterのｵﾌﾞｼﾞｪｸﾄとしてXを生成、ｶｳﾝﾀの値を表示します。
ｵﾌﾞｼﾞｪｸﾄ生成時にｶｳﾝﾀが0になっています。
生成後は、ｷｰﾎﾞｰﾄﾞからint形の変数noに入れた回数だけ、ﾒﾝﾊﾞ関数incrementによるｶｳﾝﾄｱｯﾌﾟを行いながら値を表示します。
それが終わると、もう一度ｷｰﾎﾞｰﾄﾞからint形変数noに入れた数値の回数だけｶｳﾝﾄﾀﾞｳﾝと値の表示を行います。
もちろんこのまま利用することも出来るのですが、改良点がいくつかあります。
ﾕｰｻﾞｰ定義型であるｸﾗｽCounterを使う時は、値を調べる、ｶｳﾝﾄｱｯﾌﾟ/ﾀﾞｳﾝ（ｲﾝｸﾘ/ﾃﾞｸﾘ）を行うためにvalue関数、increment関数、decrement関数を呼び出す必要があります。
int形やlong形の組み込み型と比較すると
・ﾀｲﾌﾟ数が増える→ﾀｲﾌﾟﾐｽしやすくなる
・ﾌﾟﾛｸﾞﾗﾑが冗長になる→読みにくくなる
といったﾃﾞﾒﾘｯﾄがあります。
ｸﾗｽ型ｵﾌﾞｼﾞｪｸﾄに対してｲﾝｸﾘやﾃﾞｸﾘを行う演算子を使えれば、int形やlong形と同じ感じで利用できるはず！
という事で改良していきましょう！
NewCounter.h
//カウンタクラス
#ifndef ___Class_Counter
#define ___Class_Counter
#include <limits>
class Counter{
unsigned cnt; //ｶｳﾝﾀ
public:
//ｺﾝｽﾄﾗｸﾀ ｶｳﾝﾀを0に
Counter() : cnt(0){}
//unsigned型へ変換する
operator unsigned() const {
return cnt;
}
//論理否定演算子!
bool operator!() const {
return cnt == 0;
}
//前置増分演算子++
Counter& operator++(){
if (cnt < std::numeric_limits<unsigned>::max()) cnt++;
return *this;
}
//後置増分演算子++
Counter operator++(int){
Counter x = *this;
++(*this);
return x;
}
//前置減分演算子--
Counter& operator--(){
if (cnt > 0) cnt--;
return *this;
}
//後置減分演算子--
Counter operator--(int){
Counter x = *this;
--(*this);
return x;
}
};
#endif
では早速利用してみましょう。
countertest.cpp
#include <iostream>
#include "NewCounter.h"
using namespace std;
int main()
{
int no;
Counter x;
Counter y;
cout << "Count up count:";
cin >> no;
for (int i = 0; i < no; i++)
cout << x++ << " " << ++y << "\n";
cout << "Count down count:";
cin >> no;
for (int i = 0; i < no; i++)
cout << x-- << " " << --y << "\n";
if(!x)
cout << "x is 0\n";
else
cout << "x is not 0\n";
}
実行結果（赤枠はキーボードより入力）
xには後置き、yには前置きの演算子を使いました。
ちゃんと使い分けられてますね。
変換関数と演算子関数を定義したので組み込み型と同じ感じでCounterｸﾗｽを使えるようなりました。
最初のﾌﾟﾛｸﾞﾗﾑと比べてみると使いやすい上に利用する時に簡単ですし読みやすくなりましたね。
変換関数や演算子の定義の方法はまた次回として今日はこのあたりにしておきます。
ありがとうございました。
ぷないしん
