手抜き煮込みハンバーグ

ひき肉があったので、ハンバーグを作ろうと思ったのだが、
ソースを作るのが面倒なので煮込んでみることにした。
これがかなり旨かったので、レシピ。
手抜きなのでレシピも手抜き。

【材料(1個分)】
・ひき肉 ・・・ 100gくらい
・黒コショウ ・・・ 適当
・しょうが ・・・ 少々
・パン粉 ・・・ 一掴みくらい
・シナモン ・・・ 適量
・にんにく ・・・ １片
・ケチャップ ・・・ 結構いるかも
・サラダ油 ・・・ 適量

【作り方】
ひき肉、黒コショウ、しょうが(摩り下ろすかみじん切り)、パン粉、シナモンを混ぜて、
ハンバーグを作る。
このとき気合を入れてこねた方がいいかもしれない。
フライパンを熱して油を注ぎ、みじん切りにしたにんにくをいれ、香りをつける。
ハンバーグをフライパンにいれ、両面に軽く焼き色をつける。
水をコップに半分よりちょっと多いくらい注ぎ、ケチャップを水と同量くらい入れる。
コショウ、シナモンで香りをつけ、弱火で5分煮込む。
ハンバーグをひっくり返してもう5分煮込む。
できあがり。

中が赤かったらレンジでチンする。

かなり香りがよく、旨かった。

テリヤキバーガー？

モスのテリヤキバーガーが新しくなったというCMをみたので、
行ってみた。
っで、感想。
ちなみに、感想を書くということは単にうまいとかではない。
ネタになるようなことがあったということだ。
不要な前置きも書いてみた。

テリ「なし」バーガーの間違いだった。
んでもって、肉がシャリっていった。
さらに、バニラシェイクを頼んだのに、ほんのりコーヒー風味だった。
3品(チキンバーガー、テリヤキバーガー、バニラシェイク)のうち、
まとものだったのは1品だけってどうよ(怒)
そこのモスは結構利用しているのだが、初めての経験だった。
バイトのに～ちゃんが慣れていなかっただけだと思いたい。

モスに行くときはたいてい信用してもいいと思うが、
たまにこんなこともあると用心した方がいいかもしれない。

ftpクライアント

仕事で日次業務があるのだが、
これを簡便化しようかと思って、プログラムを組んでた。
そしたら、どうしてもFTPでファイルを取得しないといけなくて、
system関数使って取得するのも癪だなぁと思い、
FTPクライアントを実装してみることにした。

まぁ、FTPの実装なんて簡単だろうと思ってたんだけど、
(サンプルも結構あるし)
意外や意外、難しかった。
getはFTPサーバからのメッセージを
クライアント側で受け取り用サーバを立てて読み取ればいいんだけど、
(日本語おかしいな)
putがどうも上手くいかない。
STORコマンドをサーバに送信すると、
確かにサーバ側にファイルは作成されているんだけど、
どうもファイルの中身がない。
おかしいなぁと思って試行錯誤するが上手くいかない。
(具体的には、サーバに対してソケットであれこれ送ってみた)
どうも、サーバ側のファイルに対して直接書き込む必要があるなぁと思いつつ、
さすがにギブアップと思って、
GNUのinetutilsの実装を見てびっくり。
fdopen使ってるよ！！
そっか、UNIXはソケットもファイルディスケットもいっしょだっけ。
とりあえずcygwinだから真似たら動いたけど、
Windowsにどうやって移植するんだろ？

とりあえず、へなちょこながら、C++っぽいFTPクライアントができた。
特徴は、streamを使って送受信できることかな。
多分、get(const string& file, std::ostream& out)のインターフェースは便利なはず。
(ってか、これがほしかっただけなんだけどね、余計な分まで実装しちゃった)

体罰

大田総理である。
今日は体罰を認める認めないの議論をしていた。
結果は反対多数で否決だったが、気に入らない点がかなりあった。

・自分では解決方法を提示しない
　→ 議論の基本かも知れないが、さすがにあそこまで逃げの姿勢を出すのはいかがなものか。
・学校＝学問をするところ
　→ そうかもしれないが、小中学校は義務「教育」機関なので、イコールではないと思う。
・学問と暴力は相反するものである
　→ 議論してれば、言葉の「暴力」もあるよなぁ。
・そもそも、体罰＝暴力とされていた
　→ 体罰は罰則のであって、イコールとするのはいかがかなものかと。

実際のところ、手段として完全禁止にするのはやっぱりどうかなぁ。
言って聞かないガキなんざ本当に山ほどみた。
それを何とかするのが教育なのかもしれんが、
殴られた痛みを知るには、殴られる必要があると思う。
「学問」では「経験」は教えられんと思う。
ま、まずは保護者をなんとかしないといけないんだろうね。
「先生にぶたれた～」と言って、
「あんたが悪いことしたんでしょ」って言う親を持つ僕。
今思えばそれが正しい姿なんだろう。

なければ作る

散々ネットを探したが、
STLコンパチの可変長配列コンテナなんてなかった。
そりゃ、そんなもの必要ないからね。
STL使ってりゃいいし。
VCならMFCやらATLやらに付属してるCArrayとか使えばいいし。
両方の選択肢がないってのが珍しいと思う。

ならしょうがない、自分でつくる。
(本当はなにか回避策があったのかもしれないが・・・)
ということで出来上がったコードがこれ。

#pragma once

class Exception
{
  public:
    Exception(const CString& msg)
         : message(msg)
    {}
    const CString what() const
    {
        return message;
    }
  private:
    CString message;
};

template< class T >
struct Node
{
    typedef Node< T > Element;
    typedef T value_type;
    value_type data;
    Element* next;
    Element* prev;

    Node(value_type value)
         : data(value), next(0), prev(0)
    { }
};

template< class T >
class iterator
{
  public:
    typedef T NodeT;
    typedef typename NodeT::value_type value_type;

    explicit iterator(NodeT* src)
         : entity(src)
    {}

    iterator< NodeT >& next()
    {
        entity = entity->next;
        return *this;
    }

    iterator< NodeT >& prev()
    {
        entity = entity->prev;
        return *this;
    }

    iterator< NodeT >& operator++()
    {
        return next();
    }
    iterator< NodeT > operator++(int)
    {
        return next();
    }

    iterator< NodeT >& operator--()
    {
        return prev();
    }
    iterator< NodeT > operator--(int)
    {
        return prev();
    }

    value_type operator*() const
    {
        return entity->data;
    }

    value_type* operator->() const
    {
        return &(entity->data);
    }

    iterator< NodeT >& operator+=(int index)
    {
        for (int i = 0; i < index; i++) {
            (*this)++;
        }
        return *this;
    }

    iterator< NodeT > operator+(int n) const
    {
        NodeT *buf = entity;
        for (int i = 0; i < n; i++) {
            buf = buf->next;
        }
        return iterator(buf);
    }

    bool operator==(const iterator< NodeT >& rhs) const
    {
        return this->entity == rhs.entity;
    }

    bool operator!=(const iterator< NodeT >& rhs) const
    {
        return !(*this == rhs);
    }

    NodeT* getEntity() const
    {
        return entity;
    }
  private:
    NodeT *entity;
};

template< class T , class _Iterator = iterator< Node< T > > >
class ArrayImpl
{
  public:
    typedef T value_type;
    typedef Node< value_type > NodeT;
    typedef unsigned int size_type;
    typedef _Iterator iterator;

  public:
    ArrayImpl()
         : first(0), last(0), count(0)
    { }

    ~ArrayImpl()
    {
        if (!empty()) {
            NodeT *cur = first;
            NodeT *temp;
            while (cur != 0) {
                temp = cur;
                cur = cur->next;
                delete cur;
            }
        }
    }
    NodeT* createEntity(const value_type& value)
    {
        return new Node< value_type >(value);
    }

    void push_back(const value_type& value)
    {
        NodeT *node = createEntity(value);
        if (empty()) {
            first = last = node;
        } else {
            node->prev = last;
            last->next = node;
            last = node;
        }
        count++;
    }

    void insert(const iterator& pos, const value_type& value)
    {
        NodeT *node = createEntity(value);
        if (empty()) {
            first = last = node;
        } else {
            NodeT *buf = first;
            while (buf == pos.getEntity()) {
                buf = buf->next;
            }
            // 最終要素なら末尾に追加
            if (buf == end().getEntity()) {
                delete node;
                push_back(value);
            } else {
                node->next = buf->next;
                node->prev = buf;
                buf->next = node;
            }
        }
    }

    bool empty() const
    {
        return count == 0;
    }

    size_type size() const
    {
        return count;
    }

    value_type at(size_type index) const
    {
        if (index > count) {
            throw Exception("Array index out of bounds.");
        }
        return *(begin() + index);
    }

    iterator begin()
    {
        return iterator(first);
    }

    iterator end()
    {
        if (last == 0) {
            return iterator(last);
        } else {
            return iterator(last->next);
        }
    }

    iterator begin() const
    {
        return iterator(first);
    }

    iterator end() const
    {
        if (last == 0) {
            return iterator(last);
        } else {
            return iterator(last->next);
        }
    }
  private:
    Node< value_type > *first;
    Node< value_type > *last;
    size_type count;

    ArrayImpl(const ArrayImpl& other);
    ArrayImpl& operator=(const ArrayImpl& rhs);
};

template< class T >
ArrayImpl< T >* nodeCopy(const ArrayImpl< T >* src)
{
    ArrayImpl< T > *dest = new ArrayImpl< T >();
    for (typename ArrayImpl< T >::iterator itr = src->begin(); itr != src->end(); itr++)
    {
        dest->push_back(*itr);
    }
    return dest;
}

// 以上
// Arrayの実体

template< class T >
class Array
{
  public:
    typedef T value_type;
    typedef unsigned int size_type;
    typedef typename ArrayImpl< value_type >::iterator iterator;
    //typedef const iterator const_iterator;
  public:
    Array(void)
         : impl(new ArrayImpl< value_type >()), count(0)
    {}

    Array(const Array< value_type >& other)
         : impl(nodeCopy(other.impl))
    { }

    Array& operator=(const Array< value_type >& rhs)
    {
        if (this != &rhs) {
            ArrayImpl< value_type > *tmp = nodeCopy(rhs.impl);
            delete impl;
            impl = tmp;
        }
        return *this;
    }
    ~Array(void)
    {
        delete impl;
    }

    void push_back(const value_type& value)
    {
        impl->push_back(value);
    }

    void insert(const iterator& pos, const value_type& value)
    {
        impl->insert(pos, value);
    }

    value_type at(size_type index) const
    {
        return impl->at(index);
    }

    iterator begin()
    {
        return impl->begin();
    }

    iterator end()
    {
        return impl->end();
    }

    iterator begin() const
    {
        return impl->begin();
    }

    iterator end() const
    {
        return impl->end();
    }

    size_type size() const
    {
        return impl->size();
    }

    bool empty() const
    {
        return impl->empty();
    }
  private:
    ArrayImpl< value_type > *impl;
    size_type count;
};

自分の使ってた部分だけSTLコンパチ。
なんで、referenceはないし、iteratorも一種類のみ。
メソッドも全然ない。つくりは超適当。
それでも、こんなの作るのに、2時間くらいかかったよ・・・orz
今のところ不具合なく動いてる。
だれか、完全STLコンパチに直してくれないかな・・・

追記：
ものすごい勢いで、リークしてた。
修正した。

追記の追記：
実はCSimpleArrayなんてのがあったよ・・・
調査不足でした・・・orz

VCのばかやろ～

VC2005EEでこそこそやっているのだが、
どうやらVCでWindowsアプリを作ると、STLとか使えないらしい。
使うとDebugモードでは動くけど、Releaseモードでは動かないという、
なんともあほみたいな現象が現れる。
どうやらCRLが問題らしいんだけど、どないせ～と。
別にListを作るのはそんなに大変じゃないんだけど、
Iteratorに対応させようと思うと気が狂いそうになったんだよね。
自分の未熟さに原因があるんだけどさ。
完全STLコンパチを目指さない方がいいのかな・・・

牛バラ肉の赤ワイン煮

ドライブに行った帰りに、来週の食材を買出しに行ったら、
牛バラ肉のブロックが売っていたので、作ってみようと思い立ってみた。
いつだったか、下宿の近くにあるイタリア料理の店でメニューに載っていたのを見て、
作ってみようと思っていたのだが、思いのほか早く実現した。
いつもはレシピを２～３くらい比べて、適当にアレンジするのだが、
今回は食べたことないものなので、
比較的簡単そうにできるレシピをまねることにした。
ということで、参考にしたレシピ：
http://mitsuka.jugem.jp/?eid=170
実にアバウトに書いてるけど(必要材料が書いてないとか)、
他のレシピと比べるとシンプルだったので、作りやすかった。

もう1品カルボナーラを作って、なんとも豪華な夕飯を食べてしまった。
多分、材料費で500円はかかってるはず(いつもは多分150円くらい)。

Visual Studio 2005 Express

職場で使ってみた。
ちょっとしたツールを作る必要があったのだが、
VB6(未だに)で作るのはいやだったので、
無許可(おいおい)でVC8で作ることにした。
さすがに.net使うとフレームワークを入れないといけないから、
WTLを使ってみた。
意外といいね。M$というだけで使ったことなかったんだけど、
Windowsで開発するなら選択肢としてはありなのかも。
ただ、M$製っぽく、中でどんな風に動いてるのかさっぱりわからん。
そこにファイルがあるはずなのに、ヘッダがないとか言われるし。
ついでにフリー版はリソースエディタがないから、
フォームの記述をするのが面倒。
フリーのリソースエディタってないのかな？

なんだかんだ言っても、開発してるときはやっぱり楽しい。
特にC++だし。

ミートソース

お昼ごはんに何を作ろうか。
ご飯は炊きたくないので、パスタにしよう。
和風はこの前作ったし、ひき肉がある。
こんな状況になったので、ミートソース風の具を作ってみた。
完全に創作なので、備忘録。

材料：
ひき肉・・・多分50gくらい
たまねぎ・・・1/4個
にんじん・・・10gもあればいいのかな？
にんにく・・・1かけら
サラダ油・・・大さじ1or2くらい
塩コショウ・・・適量
黒コショウ・・・適量
パルメザンチーズ・・・適量
ケチャップ・・・大さじ3くらいか？

作り方：
1.たまねぎ、にんじん、にんにくをみじん切りにする
2.フライパンに油をひき、にんにくを入れ香りを出す
3.ひき肉、にんじん、たまねぎをフライパンにいれ、塩コショウ、
　　黒コショウをいれ炒める
4.野菜からでた水分がなくならないうちにケチャップをいれなじませる
5.好みでパルメザンチーズを入れる

4のところで少し水を足して煮てもいいかもしれない。
5のパルメザンチーズは味を見て、塩気が足りないときにいれるといいかも
出来上がりの味を想像しながら作ると失敗しないと思う。