SmartyでPHPの関数を呼ぶ

Smartyで配列の数を取得するにはどうすればいんだろうと、調べていたら
{$array|@count}

• $array：配列
• @：$arrayが配列ですよと指定している
• count：PHPのcount関数

で出来ると言うことがわかりました。
そんでもってcount()はPHPの関数で、それはつまりSmartyからPHPの関数を呼び出すことが出来るってことです。しらなかったぁ～

photoshopで移動とかするときにグリッドや端に張り付かないようにする

え～PhotoShopってかなり出来る子なんで、選択して移動とかするときグリッドや画像の端っことかにかってに張り付いてくれますよね、でもね
「よけーなことすんじゃねぇ」って思うときがたまにあるんですよね、
こう、マウステクを駆使してちょっとだけ、ほんの１pxだけとか移動したいのにグイってなっちゃうんですよね。そんなときは
上段メニューの[ビュー]にある[スナップ]のチェックをハズします。（photshop 6.0の場合）

これです。
これで移動とかするときスナップされなくなって微調整ができます。

WEBベージ上のテキストデータをクリップボードへコピーする（IE）

IE限定ですがJScriptをつかってWEBページ上のテキスト情報をクリップボードにコピーすることができます。

愛をください。


ソースコードはこんな感じです。
JScript

HTML

愛をください。

JavaScriptでイベントハンドラを複数登録する

今日はJavaSctipで複数のイベントハンドラを登録する方法を紹介します。
JavaScriptでイベントハンドラを登録する際

• window.onload = funcA(){};
• window.onload = funcB(){};

このようにコードを記述した場合funcB()のみがイベントハンドラとして有効となります。
funcA()、funcBともにハンドラとして登録する方法はいくつかあるようですが、今回はprototype.jsというライブラリのEvent.observe()を使用します。
基本構文は

Event.observe(エレメント名, イベント名, イベントハンドラ,  isバブルアップしない)

です。バブルアップってなんだ？って感じですが、falseを設定すると親エレメントをさかのぼって全ての同イベントを実行します。
コード例はこんな感じです。

Event.observe(window, 'load', funcA(), false);
Event.observe(window, 'load', funcB(), false);

JavaScriptで現在のドキュメント（ページ）を更新する。

JavaScriptで現在のドキュメントを更新するには、

• Location.reload(force)

を使います。forceにtrueを設定するとキャッシュを無視して更新します。

PHPで配列、連想配列の一部を削除する

PHPでインデックスを指定して配列の一部を削除する、keyを指定して連装配列の一部を削除するには
unset()を使用します。

$arr = array(1, 2, 3, 4);
print_r($arr);
unset($arr[1]);
print_r($arr);

$dict = array ("a" => "aa", "b" => "bb", "c" => "cc");
print_r($dict);
unset($dict['b']);
print_r($dict);

こんな感じです。

JavaScriptでドキュメントのAnchorの位置までスクロールさせる

今日はJavaScriptでアンカー（<a>タグ）の名前を指定して画面をスクロールさせる方法を紹介します。
まずはJavaScriptのコードです。

function focusAnchor() {
    var anchors = document.anchors;
    anchors['target'].focus();

    // idでアンカーを取得する場合
//    var anchor = document.getElementById('target');
//    anchor.focus();
}

特に難しい処理はありません。目的のアンカーを取得してfocus()を呼び出しているだけです。
続いてHTMLのコードです。

target

HTML側では一点注意しなければいけないことがあります。それは

• アンカータグには必ずhref属性が必要（これがないとfocus()が反応してくれないようです）

以下サンプル
















target

C++でクラスメンバ変数を参照型にする

今日はC++でクラスのメンバ変数を参照型にする方法を紹介します。
その方法とは？！

• コンストラクタ初期化子を使用する

です。
コンストラクタ初期化子を使うとクラスメンバの生成と同時に値を代入したり、メンバのコンストラクタに引数を与えることができます。
これを利用して参照型の変数を初期化することが可能です。
サンプルコードを用意しました。

#include 
#include "Monster.h"

void main(void)
{
    int hp = 111;
    int mp = 222;

    //  Monster生成
    Monster monster(hp, mp);

    //  参照している変数の値を変更
    hp = 100;
    mp = 100;

    //  表示
    printf("HP:%d\n", monster.HP);
    printf("MP:%d\n", monster.MP);

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

#ifndef _MONSTER_H_
#define _MONSTER_H_

#include 

class Monster
{
    //----------------------------------
    //  field
    //----------------------------------
public:
    int& HP;    //  メンバ変数が参照型
    int& MP;    //  メンバ変数が参照型
    //----------------------------------
    //  method
    //----------------------------------
public:
    //  constructor
    Monster(int& _hp, int& _mp) :   //  コロンをわすれずに！
        HP(_hp),    //  初期化子
        MP(_mp)     //  初期化子
    {
        //  do nothing...
    }

};
#endif

ソースコードの内容については余りつっこまないでください（汗
時間がなくてこんな例しか作れませんでした。

C++でオブジェクトのクラス名(型名)文字列を実行時に取得する

今日はC++でオブジェクトのクラス名を実行時に取得する方法を紹介します。
紹介するといってもtypeid()という関数を使用するだけです。typeid()はtypeinfo.hで定義されているのでincludeする必要があります。
typeid()の引数には変数オブジェクトや型名(クラス名)を直接指定することが出来ます。
またtypeid()の戻り値同士を比較したりも出来ます。

サンプルコードを用意しました。

main.cpp

#include 
#include 
#include "ConcreteClass.h"

void main(void)
{
    //  ConcreteClassオブジェクト生成
    AbstractClass* obj = new ConcreteClass();

    //  型名取得
    const type_info& id = typeid(*obj);
    printf("%s\n", id.name());

    //  method()の呼び出し
    obj->method();

    //  型を直接指定し型名を取得し比較
    if (typeid(ConcreteClass) == id) {
        printf("true\n");
    }

    delete obj;

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

AbstractClass.h

#ifndef _ABSTRACT_CLASS_H_
#define _ABSTRACT_CLASS_H_

#include 
#include 

class AbstractClass
{
    //----------------------------------
    //  method
    //----------------------------------
public:
    void method() {
        //  型情報の取得
        const type_info& id = typeid(*this);

        //  表示
        printf("AbstractClass-typeid:%s\n", id.name());

        //  subMethod()の呼び出し
        this->subMethod();
    }

protected:
    virtual void subMethod() = 0;
};
#endif

ConcreteClass.h

#ifndef _CONCRETE_CLASS_H_
#define _CONCRETE_CLASS_H_

#include 
#include 
#include "AbstractClass.h"

class ConcreteClass : public AbstractClass
{
 //----------------------------------
 // method
 //----------------------------------
public:
 ConcreteClass() {
  // do nothing...
 }

 virtual ~ConcreteClass() {
  // do nothing...
 }

protected:
 virtual void subMethod() {
  // 型情報の取得
  const type_info& id = typeid(*this);

  // 表示
  printf("ConcreteClass-type_id:%s\n", id.name());
 }

};
#endif

WSH(JScript)におけるカレントディレクトリについて、その２

先日スクリプトファイルを直接実行した時とファイルやフォルダをドラッグアンドドロップした時とでは、カレントディレクトリが変わるっていう記事を書きましたが、WScript.ScriptFullNameを使用すればスクリプトファイルのあるフォルダを取得できますね。
まぁ、カレントディレクトリ＝＝スクリプトが置いてあるフォルダとか思っていた私がウマシカさんでしたｗ
スクリプトフォルダを取得する関数を作ってみました。

WScript.echo(this.getScriptFolder());

//  スクリプトフォルダの取得
function getScriptFolder() {
    return WScript.ScriptFullName.replace("\\" + WScript.ScriptName, "");
}

WSH(JScript)でフォルダ配下の全ての動画ファイルの再生時間を取得する

最近WSHの記事ばっかりでしたけどこんなの作ってました。
主な機能

1. 動画ファイルの再生時間を取得する。
2. サブフォルダも含めたフォルダ内の全ての動画ファイルの再生時間を取得する。
3. logファイルに出力する。

try {
    var main = new main(WScript.Arguments);
    main.exec();
}
catch(e) {
    WScript.echo(e);
    WScript.Quit();
}

function main (_args) {

    // Windows Media Playerコントロールオブジェクト生成
    this.objWMP = WScript.createObject("WMPlayer.OCX");
    //  FileSystemObject生成
    this.objFileSys = WScript.CreateObject("Scripting.FileSystemObject");
    //  ShellObject生成
    this.objShell = WScript.createObject("WScript.Shell");   

    //  引数の取得
    this.objArgs = _args;
    if (this.objArgs.UnNamed.count <= 0) {
        throw "ファイル叉はフォルダをドラッグ&ドロップするか\nコマンドラインから引数としてファイル又はフォルダパスを指定してください。";
    }

    //---------------------------------
    //  exec()
    //---------------------------------
    this.exec = function() {
        //  logファイルの生成（上書きモード）
        var logFileName = "PlayTimeLog.txt";
        var objLogFile = this.objFileSys.OpenTextFile(logFileName, 2, true);
        var fileCnt = 0;
        //  全ての名前なし引数について処理する
        var unNamedArgs = this.objArgs.UnNamed;
        var enu = new Enumerator(unNamedArgs);
        for (; enu.atEnd() == false; enu.moveNext()) {
            try {
                var arg = enu.item();
                fileCnt = this.logPlayTime(objLogFile, arg);
            }
            catch(e) {
                objLogFile.WriteLine(e);
            }
        }
        //  サマリー情報の書き込み
        objLogFile.WriteLine("----------------------------------------");
        objLogFile.WriteLine(fileCnt + "件のファイルを処理しました。");
        //  logファイルのクローズ
        objLogFile.Close();
        //  完了メッセーの表示
        WScript.echo(
            "mission completed\n"
            + "作業結果は\n"
            + this.objShell.CurrentDirectory
            + "\\" + logFileName + "\n"
            + "参照"
        );
    }

    //---------------------------------
    //  サブフォルダも含めて動画ファイルの再生時間をlogファイルに書き込む
    //---------------------------------
    this.logPlayTime = function (_objLogFile, _path) {
        var fileCnt = 0;
        //  パスがフォルダの場合
        if (this.objFileSys.FolderExists(_path)) {
            //  フォルダオブジェクトの生成
            var objFolder = this.objFileSys.GetFolder(_path);
            //  サブフォルダ一覧取得
            var subFolders = objFolder.SubFolders;
            //  全てのフォルダについて自分を呼び出す
            var enuSubFolders = new Enumerator(subFolders);
            for (;enuSubFolders.atEnd() == false; enuSubFolders.moveNext()) {
                fileCnt += this.logPlayTime(_objLogFile, enuSubFolders.item().Path);
            }

            //  ファイル一覧取得
            var files = objFolder.Files
            //  全てのファイルについて自分を呼び出す
            var enuFiles = new Enumerator(files);
            for (; enuFiles.atEnd() == false; enuFiles.moveNext()) {
                fileCnt += this.logPlayTime(_objLogFile, enuFiles.item().Path);
            }
        }
        //  パスがファイルの場合
        else if (this.objFileSys.FileExists(_path)) {
            //  ファイルオブジェクトの生成
            var objFile = this.objFileSys.GetFile(_path);
            //  再生時間の取得
            var time = this.getPlayTime(objFile.Path);
            //  logファイルに書き込み
            _objLogFile.WriteLine(objFile.Name + "\t" + time);
            //  ファイル数をインクリメント
            fileCnt++;
        }
        else {
            objLogFile.WriteLine("error:" + _path + "は存在しません");
        }
        return fileCnt;
    }

    //---------------------------------
    //  動画再生時間の取得
    //---------------------------------
    this.getPlayTime = function(_filePath) {
        // 動画ファイルの読み込み
        this.objWMP.URL = _filePath; 

        // ファイル準備中状態の間待つ
        while (this.objWMP.playState == 9) {
            WScript.Sleep(500);
        }

        // 再生時間取得
        return this.objWMP.currentMedia.durationString;
    }

}

ソースコード長いｗ

WSH(JScript)でDictionaryを使ってみる

今日はWSH(JScript)のDictionaryを紹介します。

var datas = {
    a:"aa",
    b:"bb",
    c:"cc"
};

//  辞書(Dictionary)の生成
var objDict = WScript.createObject("Scripting.Dictionary");
for (var key in datas) {
    //  要素の追加
    objDict.add(key, datas[key]);
}

//--------------------------------------
//  プロパティ
//--------------------------------------
//  要素数の取得
var cnt = objDict.Count;
WScript.echo("要素数の取得：" + cnt);

//  要素の取得
WScript.echo("要素の取得１：" + objDict.Item("a"));
WScript.echo("要素の取得２：" + objDict("a"));

//  キーを変更する
objDict.Key("a") = "A";
WScript.echo("\"A\"の値：" + objDict.Item("A"));

//--------------------------------------
//  メソッド
//--------------------------------------

//  キーの存在判定
if (objDict.Exists("A")) {
    WScript.echo("\"A\"は存在します");
}

//  Enumeratorを使用した反復
var enuDict = new Enumerator(objDict);
var strItems = "";
for (; enuDict.atEnd() == false; enuDict.moveNext()) {
    strItems += objDict(enuDict.item()) + ",";
}
WScript.echo(strItems);



//  キーを指定して削除
objDict.Remove("b");
objDict.RemoveAll();
WScript.echo("要素数：" + objDict.Count);

紹介しておいてなんですが、機能が微妙な上にJScript(JavaScript)は連装配列が使えるのでDictionaryは使わないかもしれません。

JavaScript(JScript)で連装配列を反復する（なめる）

今日はJavaScript(JScript)で連装配列を反復する方法を紹介します。

var array = new Array();

array["a"] = "aa";
array["b"] = "bb";

for (var key in array) {
    //  WScript.echo(array[key]);   // WSHの場合
    alert(array[key]);
}

WSH(JScript)で動画の再生時間を取得する

今日はWSH(JScript)で動画の再生時間を取得する方法を紹介します。

try {
    // Windows Media Playerコントロールオブジェクト生成
    var objWMP = WScript.createObject("WMPlayer.OCX");

    // 動画ファイルの読み込み
    objWMP.URL = ".\\aaa.wmv"; 

    // ファイル準備中状態の間待つ
    while (objWMP.playState == 9) {
        WScript.Sleep(500);
    }

    // 再生時間取得と表示
    WScript.echo(objWMP.currentMedia.durationString);
}
catch(e) {
    WScript.echo(e);
    WScript.Quit();
}

「aaa.wmv」というファイルの再生時間を表示しています。

WSH(JScript)でコレクションを反復する

今日はWSH(JScript)でコレクションを反復する方法を紹介します。
今回 紹介する方法は

• Enumratorを使用して反復する

です。
例として指定フォルダのファイル一覧を表示するコードを記述します。

try {
    //  FileSystemObject生成
    var objFileSys = WScript.CreateObject("Scripting.FileSystemObject");

    //  ファイル一覧(コレクション)取得
    var folder = objFileSys.GetFolder("C:");
    var files = folder.Files;

    //  Enumeratorを使用してファイル一覧を反復する
    var str = "";
    var iter = new Enumerator(files);
    for (;iter.atEnd() == false; iter.moveNext()) {
        str += iter.item().Name + "\n";
    }

    //  ファイル一覧表示
    WScript.echo(str);
}
catch (e) {
    WScript.echo(e);
    WScript.quit();
}

構造体(struct)の宣言方法にかんする小技

今日はC、C++で構造体を宣言する際の小技を紹介します。小技にもほどがあるって感じなんですけど変数を定義する際にstructっていちいちつけなくても良くなる方法です。
下記がコードです。

#include 

struct Character {
    char name[32];
    int HP;
    int MP;
};

typedef struct {
    char name[32];
    int attack;
}Weapon;

void main (void)
{
    struct Character character; //  struct が必要
    Weapon knife;   //  struct が不要

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

}

typedefを使用してデータ型に新しい名前を付けることが出来るのですが、Weaponは宣言を直接typedefしています。

とりあえずconst！

ってぐらい変数にはconst付けてます。ん？だめ？
理由としては

• コンパイラにバグを見つけさせる為

です。constが付いているとその変数は読み取り専用となる為、誤って値を代入したり、オブジェクトの内容が変わるようなメソッドを呼び出したり出来なくなります。
具体的に説明すると、

const int value = 1;
    if(value = 1) // ← ==のつもり

こんなのとか

const CHoge hoge;
    hoge.clear(); // ←本当はclearしてはダメ

とかコンパイルエラーになります。
C#でも使えたらいいのにって思うのは私だけ？

C,C++で配列を反復する（なめる）

今日はC,C++で配列を反復する方法を２つ紹介します。

• 配列の要素数を使用して反復する。
• 番兵を使用して反復する。

そんなに難しくないのでコードをサクッと記述します。

#include 

void main(void)
{

    //----------------------------------
    // サイズを求めて反復に使用する
    //----------------------------------
    const char* strArray[] = {
        "1",
        "2",
        "3",
    };
    const int length = sizeof(strArray) / sizeof(strArray[0]);    // 配列のサイズ算出
    printf("length:%d\n", length);
    for (int i = 0; i < length; i++) {  // length未満の間ループ
        printf("%s\n", strArray[i]);
    }

    printf("--------\n");

    //----------------------------------
    // 番兵を立てる
    //----------------------------------
    const char* strArray2[] = {
        "a",
        "b",
        NULL,   // 番兵
    };

    for (int i = 0; strArray2[i]; i++) {    // false(NULL)以外の間ループ
        printf("%s\n", strArray2[i]);
    }

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

コンストラクタで仮想関数を呼び出す（C++）

C++ではコンストラクタで仮想関数を呼び出しても意図した動作にならないんですよね、どんな動きになるかといいますと、オーバーライドした関数ではなく基底クラス(親クラス)の仮想関数が呼び出されてしまいます。
検証用のコードを用意しましたのでまずはクラス図を見てみましょう。

単純な継承関係のクラスを二つ用意しました。init()は仮想関数になっています。
つぎにソースを見てみましょう、用意したのは次のファイルです。

• main.cpp
• Character.h
• CharacterMonster.h

まずはCharacter.hです。

#ifndef _CHARACTER_H_
#define _CHARACTER_H_

#include 
class Character
{
public:
    // constructor
    Character() {
        this->init();
    }

    // destructor
    ~Character() {
        // do nothing...
    }

protected:
    virtual void init() {   //  仮想関数で定義
        printf("init Character\n");
    }
};
#endif

次にCharacterMonster.hです。

#ifndef _CHARACTER_MONSTER_H_
#define _CHARACTER_MONSTER_H_

#include "Character.h"

class CharacterMonster : public Character
{
public:
 // constructor
 CharacterMonster() {
  // do nothing...
 }

 // destructor
 virtual ~CharacterMonster() {
  // do nothing...
 }

protected:
 virtual void init() { // オーバーライド
  printf("init Character Monster\n");
 }
};
#endif

最後にmain.cppです。

#include "CharacterMonster.h"
#include 

void main(void)
{
    Character* character = new CharacterMonster();
    delete character;

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

init()はオーバーライドされているのでこのプログラムを実行すると「init Character Monster」が表示されると思いきや「init Character」が表示されてしまいます。
ということでコンストラクタで仮想関数を呼び出しても意図した動作になりませんでした。
ちなみにinit()を純粋仮想関数にした場合は実体がないためリンクエラーとなります。

なのでinit()メソッドをいつも用意するようにしているのですけどinit()を呼び出すのを忘れたりもするんですよね、ケースバイケースなのかなぁ？。

C++でStrategyパターン

Strategyパターンはアルゴリズム（振る舞い）をカプセル化（クラス化）するパターンです。
Singletonパターンのメリットは

• 振る舞いを簡単に交換することが出来る。
• 振る舞いを動的に交換することが出来る。

です。

まずは次のクラス図をご覧ください

見ました？なんか複雑だからってあんまり見てないでしょ？
ちゃんとクリックして拡大して見てくださいね。
このクラス図で重要なのは

• MonsterStrategyクラス

ですMonsterのmove()の振る舞いをMonsterStrategyクラスに委譲しています。
つぎにソースを見てみましょう、用意するのは次のファイルです。

• main.cpp
• Monster.h
• Monster.cpp
• MonsterStrategy.h
• MonsterStrategy.cpp
• MonsterStrategyFreedom.h
• MonsterStrategyFreedom.cpp
• MonsterStrategyGangan.h
• MonsterStrategyGangan.cpp

まずはMonster.hです。

#ifndef _MONSTER_H_
#define _MONSTER_H_

#include "MonsterStrategy.h"

class Monster
{
    //----------------------------------
    // constant
    //----------------------------------
    #define STRATEGY_MAX_NUM 8

    //----------------------------------
    // field
    //----------------------------------
private:
    MonsterStrategy* m_strategyDictionary[STRATEGY_MAX_NUM];    //  ①
    MonsterStrategy::Type m_currentStrategyType;                //  ②

    //----------------------------------
    // property
    //----------------------------------
public:
    const MonsterStrategy::Type getCurrentStrategyType();
    Monster& setCurrentStrategyType(const MonsterStrategy::Type _type);

private:
    MonsterStrategy** getStrategyDictionary();
    const bool addStrategy(const MonsterStrategy::Type _type);

    //----------------------------------
    // mothod
    //----------------------------------
public:
    // constructor
    Monster();

    // destructor
    ~Monster();

    // initialize
    const bool init();

    // move
    Monster& move();    //  ③

private:
    // operator(=)
    Monster& operator=(const Monster& _monster);
};
#endif

①Monsterの行動アルゴリズム辞書です。今回は配列を使用していますがDictionary系クラスを私用するのが良いでしょう。
②現在の行動アルゴリズムです。
③Monsterに行動指示を出します。

次にMonster.cppです。

#include "Monster.h"
#include "MonsterStrategyFreedom.h"
#include "MonsterStrategyGangan.h"
#include 

//-----------------------------------
// property
//-----------------------------------
const MonsterStrategy::Type Monster::getCurrentStrategyType()
{
    return this->m_currentStrategyType;
}
Monster& Monster::setCurrentStrategyType(const MonsterStrategy::Type _type)
{
    printf("strategy %d -> %d\n", this->getCurrentStrategyType(), _type);
    this->m_currentStrategyType = _type;
    return *this;
}
MonsterStrategy** Monster::getStrategyDictionary()
{
    return this->m_strategyDictionary;
}
const bool Monster::addStrategy(const MonsterStrategy::Type _type)
{
    if (STRATEGY_MAX_NUM <= _type) {
        throw "error strategy max num";
    }
    MonsterStrategy** strategyDictionary = this->getStrategyDictionary();
    if (strategyDictionary[_type] != NULL) {
        // already exist
        return false;
    }

    switch (_type) {
        case MonsterStrategy::ST_FREEDOM:
            strategyDictionary[_type] = new MonsterStrategyFreedom();
            break;
        case MonsterStrategy::ST_GANGAN:
            strategyDictionary[_type] = new MonsterStrategyGangan();
            break;
        default:
            throw "invalid type";
            break;
    }

    return true;
}

//-----------------------------------
// method
//-----------------------------------
// constructor
Monster::Monster() :
    m_currentStrategyType(MonsterStrategy::ST_FREEDOM)
{
    // do nothing...
}
// destructor
Monster::~Monster()
{
    MonsterStrategy** strategyDictionary = this->getStrategyDictionary();
    for (int i = 0; i < STRATEGY_MAX_NUM; i++) {
        delete strategyDictionary[i];
    }

}

// initialize
const bool Monster::init()
{
    MonsterStrategy** strategyDictionary = this->getStrategyDictionary();
    for (int i = 0; i < STRATEGY_MAX_NUM; i++) {
        strategyDictionary[i] = NULL;
    }

    const MonsterStrategy::Type strategyTypeArray[] = {
        MonsterStrategy::ST_FREEDOM,
        MonsterStrategy::ST_GANGAN,
    };
    const int size = sizeof(strategyTypeArray) / sizeof(MonsterStrategy::Type); //  ①
    for (int i = 0; i < size; i++) {
        this->addStrategy(strategyTypeArray[i]);
    }

    return true;
}

// move
Monster& Monster::move()
{
    MonsterStrategy** strategyDictionary = this->getStrategyDictionary();
    strategyDictionary[this->getCurrentStrategyType()]->move(*this);
    return *this;
}

①配列のサイズを求めています。

次にMonsterStrategy.hです。

#ifndef _MONSTER_STRATEGY_H_
#define _MONSTER_STRATEGY_H_

class Monster;

class MonsterStrategy
{
public:
    //----------------------------------
    // constant
    //----------------------------------
    enum Type {
        ST_FREEDOM = 0, // 自由
        ST_GANGAN,  // がんがん行こうぜ
    };  //  ①

    //----------------------------------
    // mothod
    //----------------------------------
public:
    // constructor
    MonsterStrategy();

    // destructor
    virtual ~MonsterStrategy();

    // move
    virtual void move(Monster& _monster) = 0;   //  ②

private:
    // operator(=)
    MonsterStrategy& operator=(const MonsterStrategy& _monsterStrategy);

};
#endif

①Monsterの行動アルゴリズムのタイプです。
②Monsterの行動アルゴリズムが記述されているメソッドです。タイプ毎にアルゴリズムは違うので純粋仮想関数にしています。

次にMonsterStrategy.cppです。

#include "MonsterStrategy.h"
#include 

//----------------------------------
// mothod
//----------------------------------
// constructor
MonsterStrategy::MonsterStrategy()
{
    // do nothing...
}

// destructor
MonsterStrategy::~MonsterStrategy()
{
    // do nothing...
}

特に何も実装はなしです。
次に
MonsterStrategyFreedom.h
MonsterStrategyFreedom.cpp
MonsterStrategyGangan.h
MonsterStrategyGangan.cpp
をまとめて記述します。

#ifndef _MONSTER_STRATEGY_FREEDOM_H_
#define _MONSTER_STRATEGY_FREEDOM_H_

#include "MonsterStrategy.h"

class Monster;

class MonsterStrategyFreedom : public MonsterStrategy // ①
{
public:

    //----------------------------------
    // mothod
    //----------------------------------
public:
    // constructor
    MonsterStrategyFreedom();

    // destructor
    ~MonsterStrategyFreedom();

    // move
    void move(Monster& _monster);   //  ②

private:
    // operator(=)
    MonsterStrategyFreedom& operator=(const MonsterStrategyFreedom& _monsterStrategyFreedom);

};
#endif

#include "MonsterStrategyFreedom.h"
#include "MonsterStrategy.h"
#include "Monster.h"
#include 

//----------------------------------
// mothod
//----------------------------------
// constructor
MonsterStrategyFreedom::MonsterStrategyFreedom()
{
    // do nothing...
}

// destructor
MonsterStrategyFreedom::~MonsterStrategyFreedom()
{
    // do nothing...
}

// move
void MonsterStrategyFreedom::move(Monster& _monster)
{
    printf("freedom\n");
}

#ifndef _MONSTER_STRATEGY_GANGAN_H_
#define _MONSTER_STRATEGY_GANGAN_H_

#include "MonsterStrategy.h"

class Monster;

class MonsterStrategyGangan : public MonsterStrategy    //  ①
{
public:

    //----------------------------------
    // mothod
    //----------------------------------
public:
    // constructor
    MonsterStrategyGangan();

    // destructor
    ~MonsterStrategyGangan();

    // move
    void move(Monster& _monster);   //  ②

private:
    // operator(=)
    MonsterStrategyGangan& operator=(const MonsterStrategyGangan& _monsterStrategyGangan);

};
#endif

#include "MonsterStrategyGangan.h"
#include "MonsterStrategy.h"
#include "Monster.h"
#include 

//----------------------------------
// mothod
//----------------------------------
// constructor
MonsterStrategyGangan::MonsterStrategyGangan()
{
    // do nothing...
}

// destructor
MonsterStrategyGangan::~MonsterStrategyGangan()
{
    // do nothing...
}

// move
void MonsterStrategyGangan::move(Monster& _monster)
{
    printf("inochi\n");
}

①MonsterStrategyを継承しています。
②オーバーライドしたmove()メソッドです。

最後にmain.cppです。

#include "Monster.h"
#include 

void main(void)
{
    Monster monster;    //  モンスター生成
    monster.init();     //  初期化
    monster.move();     //  move
    monster.setCurrentStrategyType(MonsterStrategy::ST_GANGAN); //  戦略変更
    monster.move();     //  move

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

以上でStrategyパターンの説明は終わりです。クラス数は少し多いですがそんなに難しいパターンではないはずです。
ソースコードはコピペで動かせるハズですので是非試してみてください。