C++でenumにtoStringを実装してみる

今日は、C++でenumにtoString()を実装してみたいと思います。
え！？、出来るのかって？クラスでカプセル化するだけですがなにか・・・？
ってことでクラス図です。

状態(State)を管理するenumを適当に宣言してクラスのメンバ変数としてます。
んでもってtoString()メソッドを宣言してあります。
 つぎにソースを見てみましょう、用意するのは次のファイルです。

• main.cpp
• EState.h
• EState.cpp

まずはEState.hです。

view plainprint?

1. #ifndef _E_STATE_H_  
2. #define _E_STATE_H_  
3.   
4. enum State {    //  ①  
5.     WAIT_INIT = 0,  
6.     IDLE,  
7.     PLAY,  
8.     PAUSE,  
9. };  
10.   
11. class EState {  
12.     //----------------------------------  
13.     //  フィールド  
14.     //----------------------------------  
15. private:  
16.     State m_state;  //  状態  
17.   
18.     //----------------------------------  
19.     //  プロパティ  
20.     //----------------------------------  
21. private:    //  ②  
22.     //  状態取得  
23.     const State getState() const ;  
24.     //  状態設定  
25.     EState& setState(const State _state);  
26.   
27.     //----------------------------------  
28.     //  メソッド  
29.     //----------------------------------  
30. public:  
31.     //  コンストラクタ  
32.     EState();  
33.     EState(const EState& _state);   //  ③  
34.     EState(const State _state);  
35.   
36.     //  デストラクタ  
37.     ~EState();  
38.   
39.     //  operator  
40.     operator State() const; //  ④  
41.     EState& operator=(const EState& _state);    //  ⑤  
42.   
43.     //  toString  
44.     const char* toString() const;   //  ⑥  
45. };  
46. #endif   

#ifndef _E_STATE_H_
#define _E_STATE_H_

enum State {    //  ①
    WAIT_INIT = 0,
    IDLE,
    PLAY,
    PAUSE,
};

class EState {
    //----------------------------------
    //  フィールド
    //----------------------------------
private:
    State m_state;  //  状態

    //----------------------------------
    //  プロパティ
    //----------------------------------
private:    //  ②
    //  状態取得
    const State getState() const ;
    //  状態設定
    EState& setState(const State _state);

    //----------------------------------
    //  メソッド
    //----------------------------------
public:
    //  コンストラクタ
    EState();
    EState(const EState& _state);   //  ③
    EState(const State _state);

    //  デストラクタ
    ~EState();

    //  operator
    operator State() const; //  ④
    EState& operator=(const EState& _state);    //  ⑤

    //  toString
    const char* toString() const;   //  ⑥
};
#endif 

①enumを宣言しています。

②状態のgetter、setterですがインタフェースを減らすためにprivateにしてあります。

③コピーコンストラクタです。

④キャストoperatorです。これによりEStateからStateへの代入を可能にしています。後ろにconstが着いているのはconst化された変数からも呼び出せるようにです。

⑤代入operatorです。

⑥toString()メソッドです。

つぎに、EState.cppです。

view plainprint?

1. #include "EState.h"  
2.   
3. //----------------------------------  
4. //  プロパティ  
5. //----------------------------------  
6. //  状態取得  
7. const State EState::getState() const  
8. {  
9.     return this->m_state;  
10. }  
11. //  状態設定  
12. EState& EState::setState(const State _state)  
13. {  
14.     this->m_state = _state;  
15.     return *this;  
16. }  
17.   
18. //----------------------------------  
19. //  メソッド  
20. //----------------------------------  
21. //  コンストラクタ  
22. EState::EState() :  
23.     m_state(WAIT_INIT)  //  ①  
24. {  
25.     // do nothing...  
26. }  
27. EState::EState(const EState& _state) :  
28.     m_state(WAIT_INIT)  //  ①  
29. {  
30.     *this = _state;  
31. }  
32. EState::EState(const State _state) :  
33.     m_state(WAIT_INIT)  //  ①  
34. {  
35.     this->m_state = _state;  
36. }  
37.   
38. //  デストラクタ  
39. EState::~EState()  
40. {  
41.     //  do nothing...  
42. }  
43.   
44. //  operator  
45. EState::operator State() const  
46. {  
47.     return this->m_state;  
48. }  
49. EState& EState::operator=(const EState& _state)  
50. {  
51.     this->m_state = _state.m_state;  
52.     return *this;  
53. }  
54.   
55. //  toString  
56. const char* EState::toString() const  
57. {  
58.     static const char* strArray[] = {  
59.         "WAIT_INIT",  
60.         "IDLE",  
61.         "PLAY",  
62.         "PAUSE",  
63.     };  
64.   
65.     return strArray[this->getState()];  //  ②  
66. }   

#include "EState.h"

//----------------------------------
//  プロパティ
//----------------------------------
//  状態取得
const State EState::getState() const
{
    return this->m_state;
}
//  状態設定
EState& EState::setState(const State _state)
{
    this->m_state = _state;
    return *this;
}

//----------------------------------
//  メソッド
//----------------------------------
//  コンストラクタ
EState::EState() :
    m_state(WAIT_INIT)  //  ①
{
    // do nothing...
}
EState::EState(const EState& _state) :
    m_state(WAIT_INIT)  //  ①
{
    *this = _state;
}
EState::EState(const State _state) :
    m_state(WAIT_INIT)  //  ①
{
    this->m_state = _state;
}

//  デストラクタ
EState::~EState()
{
    //  do nothing...
}

//  operator
EState::operator State() const
{
    return this->m_state;
}
EState& EState::operator=(const EState& _state)
{
    this->m_state = _state.m_state;
    return *this;
}

//  toString
const char* EState::toString() const
{
    static const char* strArray[] = {
        "WAIT_INIT",
        "IDLE",
        "PLAY",
        "PAUSE",
    };

    return strArray[this->getState()];  //  ②
} 

①初期化指定子で初期状態を設定しています。

②対応する文字列を返却しています。なにげないコードですがデータとロジックを分けることによってバグが少なくメンテナンスが容易になっています。

最後にmain.cppです。

view plainprint?

1. #include <stdio.h>  
2. #include "EState.h"  
3.   
4. void main(void)  
5. {  
6.     const EState state; //  ①  
7.     printf("state:%s\n", state.toString());   //  ②  
8.     const State tempState = state;  //  ③  
9.   
10.     printf("hit any key...");  
11.     while(getchar() == EOF){}  
12. }  
13. </stdio.h>  

#include 
#include "EState.h"

void main(void)
{
    const EState state; //  ①
    printf("state:%s\n", state.toString());   //  ②
    const State tempState = state;  //  ③

    printf("hit any key...");
    while(getchar() == EOF){}
}

①実装したEStateクラスを使用してstateを定義しています。

②toString()メソッドを呼び出して出力しています。

③キャストoperatorを実装しているのでEState型からState型への代入も可能です。

以上ですが、たかがtoString()の為だけにこれだけのコードを書かないと行けないC++ってやっぱり生産性が低いのかな・・・？