ObjectOriented

それぢゃいかんだろぉ

επιστημη — Wed, 30 Jul 2008 09:49:00 GMT

拡張メソッドによるなんちゃって多重継承に風穴を空けてみた。

    Android RTI = new Android();
    RTI.move();
    IMachine m = RTI; m.move();
    IHuman   h = RTI; h.move();

IMachine/IHumanにキャストしただけで
Androidの歩き方を忘れちゃいます。

正統(?)多重継承(C++)だと:

#include <iostream>

class Machine {
public:
virtual void move()
{ std::cout << "計算機がモーターを制御します\n"; }
};

class Human {
public:
virtual void move()
{ std::cout << "神経系が筋肉を制御します\n"; }
};

class Android : public Machine, public Human {
public:
virtual void move()
{ std::cout << "ギコギコ歩きますー\n"; }
};

int main() {
Android RTI;
RTI.move();
Machine* m = &RTI; m->move();
Human* h = &RTI; h->move();
};

ちゃんと継承してるんで、ちゃんと"ギコギコ"歩きます。

それでいいんですかぃ?

επιστημη — Wed, 30 Jul 2008 06:29:00 GMT

某所にて
「インターフェースに対して拡張メソッドでメソッドを追加するようにすれば、
事実上多重継承が実現できます」

ってゆーてた。えー、どゆことソレ? って突っ込んでみたところ:

interface Iほげらぶる {};

static class ほげらぶる実装 {
    public static void ほげ(this Iほげらぶる hoge) {
      Console.WriteLine("ほげほげー");
    }
}

interface Iぱよらぶる {};

static class ぱよらぶる実装 {
    public static void ぱよ(this Iぱよらぶる payo) {
      Console.WriteLine("ぱよぱよー");
    }
}

class ぺも : Iほげらぶる, Iぱよらぶる {
    public static void Main() {
      ぺも p = new ぺも();
      p.ほげ();
      p.ぱよ();
    }
}

なるほど、拡張メソッドによってインタフェースに実装を貼り付けることが
できるんだから、実装の貼り付いたインタフェースを多重継承すれば双方の
実装を継承できるってわけか。

でもねー、シグニチャがカブったらどないすんのよ。

interface IMachine {};

static class MachineImpl {
    public static void move(this IMachine machine) {
      Console.WriteLine("計算機がモーターを制御します");
    }
}

interface IHuman {};

static class HumanImpl {
    public static void move(this IHuman human) {
      Console.WriteLine("神経系が筋肉を制御します");
    }
}

class Android : IMachine, IHuman {
    public void move() {
      Console.WriteLine("ギコギコ歩きますー");
    }
    public static void Main() {
      Android RTI = new Android();
      RTI.move();
    }
}

Androidがmoveを再定義できるから破綻は免れたけども...
これでも多重継承できたというてえぇのやろうか。意見求ム。

なんてこったぃ

επιστημη — Sun, 06 Apr 2008 01:02:00 GMT

ぁぅぅぅ…やっぱし突っ込んでもらえなひ orz

どうやら突っ込む隙がないらしい。
いつものことながら"何を喋るか"は決めてるけども"どう喋るか"は成り行き任せ。
セッション原稿なんざこしらえたためしがありません。
んだから突っ込みドコロ満載なハズなんだけど。

かといってねぇ、意図的に穴を空けることはできるんだけども
あまりにミエミエな穴をわざわざつついて餌食になるのも、ねぇ ^^;

ストリーム・オーディエンスにはよくわかんなかったかも知れんですね。
なのでアフターケア、今回のプロジェクトです。

明日の宿題

επιστημη — Fri, 04 Apr 2008 11:21:00 GMT

わんくま東京勉強会#19:オブ熱Ⅲの(ぷちネタバレ兼)宿題です。

以下のプロジェクト(Visual Studio 2005/C#)をベースに、
出題者の意図を汲み取り、実装しなさい。

[追記] できあがりはこんなです。

オブ熱リーク

επιστημη — Thu, 20 Mar 2008 15:37:00 GMT

ネタ元 → 牛乳ラーメンを作ってみたと "矢継ぎ早"ってこーゆーことなんかしら

DECORATORちら見。
全貌は4/5わんくま東京勉強会「オブ熱３」を待て!

using System;

interface Iラーメン {
string 味();
}

class さっぽろ一番醤油味 : Iラーメン {
public string 味() { return "醤油味"; }
}

class 中華三昧北京風拉麺 : Iラーメン {
public string 味() { return "塩味"; }
}

class 牛乳ラーメン : Iラーメン {
private Iラーメンベース;
public 牛乳ラーメン(Iラーメン元ネタ) { ベース = 元ネタ; }
public string 味() {
return "牛乳でまろやかにした" + ベース.味();
}
}

class Program {
public static void Main() {
    Iラーメンはつねラーメン = new 牛乳ラーメン(new さっぽろ一番醤油味());
    Console.WriteLine(はつねラーメン.味());
    Iラーメンえぴによる追試 = new 牛乳ラーメン(new 中華三昧北京風拉麺());
    Console.WriteLine(えぴによる追試.味());
}
}

ネタ募集。

επιστημη — Sat, 08 Mar 2008 19:23:00 GMT

わんくま東京勉強会4月5日はオブ熱#4の予定。

ネタもないのにスピーカに手ぇ挙げちゃいました。
なのでお題を頂戴したく。

昨年12月のセッションではリクエストにお応えして
"状態遷移: state-pattern" をやりました → 東京勉強会#15ネタ決定

これがかなり好評だったのね。
「他の便利なデザパタも解説してくれぃ!」ってご意見もちらほらと
いただきました。

ご希望あります? デザパタに限らず。

自然界のモデリングは如何に困難か

επιστημη — Tue, 26 Feb 2008 10:21:00 GMT

ネタ元 → 多重継承について問うてみた

// C#が多重継承できたと思いねぇ
class 子 : 父, 母 { ... }

...違う、こうじゃないハズ。

interface I♂ {}
interface I♀ {}
interface I親 { IEnumerable<I子> 子供たち { get; } }
interface I父 : I親, I♂ {}
interface I母 : I親, I♀ {}
interface I子 {
I父おとぉたま { get; }
I母おかぁたま { get; }
}
interface I男の子 : I子, I♂ {}
interface I女の子 : I子, I♀ {}

...ダメなんだよね。
これじゃ子供はどんなに成長しようとも親になれない、お家断絶です。
生物としての親とか子とかは生物の属性あるいは状態なワケよ。
子ができたとたんに親状態に遷移するのよね。
# 性別はインスタンス生成時に固定されるけどさ。

なので自然界のアナロジーでオブジェクト指向を語るココロミは
極めて狭い枠組みに制限しないとあちこちボロが出る。
この例だと"成長/繁殖しない"という"ありえない制限"を与えにゃなりません。

わんくま東京勉強会で物議をかもした(?) 「ドラえもんモデル」では
ドラえもんはクラスなのかインスタンスなのかが揺れてたように思えます。
インスタンスとしてのドラえもんはクラスとしてのドラえもんの
シングルトン・インスタンスであったのかなー、とか。

ModelとViewは分離し難し

επιστημη — Wed, 30 Jan 2008 23:29:00 GMT

ちょいとした内製アプリを頼まれてて、C#でこりこり書いてるですよ。

扱うデータ自体がTree構造なのでファイルとしての表現は無難にXML、
見てくれはやっぱり無難なTreeViewと。
TreeViewは親子関係を持ったTreeNodeのコンテナとなってます。
XMLのelementときっちり対応がとれますです。

んで、XMLelementの属性の類をclassなりstructなりにまとめ、
TreeNode.Tag 使ってぶら下げ、elementの親子関係はTreeNodeに任せます。

...なんてことやってるとどうにも居心地が悪いんですわ。
つまりね、TreeViewあるいはTreeNodeがViewであると同時に
データとその繋がりを表現したModelそのものになっちまうですよ。
TreeView/TreeNodeそれぞれに対応したModelが用意されていて、
Modelの操作と連動してTreeViewの見え方が変化してくれるなら、
Model/Viewアーキテクチャに則った設計なり実装ができるだろうし、
ModelとXML間のマーシャル・ルールさえ用意してあげれば
XMLをModelに食わせただけでViewができあがるんちゃうかなー
とか妄想するです。

なんてんだろ、きょうびのRADというかIDEというか、
かなりView側に傾いてるように感じます。
本来Model側にあるはずの多くのものがFormの
メンバになってしまうよな。
僕は畑が違うんでよくわかんないんだけど、データベース絡み
ってそれがかなり顕著じゃないのかしら。
データソースだのデータセットだのはModelに置かれるはずのものですよねぇ。

これが悪名高き"魔のダイヤモンド"問題

επιστημη — Mon, 19 Nov 2007 16:15:00 GMT

ネタ元 → 親の子、子知らず（Ｃ＋＋ virtual キーワード)

ダイヤモンド継承だと予想外の挙動を示す典型的な例。

#include <iostream>
#include <string>

// 抽象猫
class AbstractCat {
public:
virtual std::string sound() const { return "にゃー"; }
};

// 生猫
class Cat : virtual AbstractCat {
public:
// 基底クラスの鳴き声で鳴く
void MakeSound() const { std::cout << sound() << std::endl; }
};

// 機械猫
class RoboCat : virtual AbstractCat {
public:
// できそこないの機械猫はまだ巧く鳴けない
virtual std::string sound() const { return "#$&*|ふじこ"; }
};

// アンドロ猫(生猫と機械猫のあいのこ)
class AndroidCat : public Cat, public RoboCat {
public:
// 電源投入時、一度鳴く
void power_on() { MakeSound(); }
};

int main() {
AndroidCat kitty; // アンドロ猫起動!
kitty.power_on();
}

さて、アンドロ猫は電源投入時になんと鳴くでしょ?
AndroidCat::power_on() から Cat::MakeSound() が呼ばれます。
Cat::MakeSound() は基底クラス(AbstractCat)で定義された
virtual-funcition: sound() で鳴き声を手に入れ、鳴いてます。

ですから実行結果は...
#$&*|ふじこ

です。えー!?

模範になってない解答(C++版)

επιστημη — Sat, 10 Nov 2007 22:40:00 GMT

模範になってない解答をC++で。

なんかここんとこC#ばっかやってます。
C#ってばちょこちょこっとお試し書くのに楽なもんだから、
秀丸で書いてコマンドラインで csc 使ってばっか。
たまにゃC++で遊んであげよぉ。

#include <iostream>
#include <string>

using namespace std;

// 鳴くもんインタフェース
class ISound {
public:
virtual ~ISound() {}
virtual void SetCount(int n) =0;
virtual void Sound() const =0;
};

// 鳴きますぃーん。
// おたくのにゃんこはもっと可愛く鳴くでしょう
// オリジナルのらぶりー鳴きますぃーんを作ってあげてね(はあと
class SoundImpl : virtual public ISound {
private:
string sound_;
int count_;
public:
SoundImpl(string s) : sound_(s), count_(1) {}
virtual void SetCount(int n) { count_ = n; }
virtual void Sound() const {
    for ( int i = 0; i < count_; ++i )
      cout << sound_;
    endl(cout);
}
};

// Animalそれ自体は鳴き方を知らず、
// 導出クラスより受け渡されるISoundに移譲する。
class Animal : virtual public ISound {
private:
ISound* sound_;
protected:
Animal(ISound* s) { sound_ = s; }
public:
virtual ~Animal() { delete sound_; }
virtual void SetCount(int n) { sound_->SetCount(n); }
virtual void Sound() const { sound_->Sound(); }
};
class Dog : public Animal
{ public: Dog() : Animal(new SoundImpl("わん")) {} };
class Cat : public Animal
{ public: Cat() : Animal(new SoundImpl("にゃー")) {} };

int main() {
    Animal* animal;
    animal = new Dog();
    animal->Sound();
    animal->SetCount(3);
    animal->Sound();
    delete animal;
    animal = new Cat();
    animal->Sound();
    delete animal;
}