C++/スクリプト/言語仕様/ユーザー定義型

ユーザー定義型

概要

＊１ : 全部0（規定値）で初期化。
structでも許さない理由は，static変数にstructな変数を定義すると，初期化時に関数コールが走ってしまうため。
関数コールは.init初期化が終わった後から呼び出すように統一したい。

interface

• C#,Dのinterfaceと同じ
• interfaceは複数にinterfaceを継承することができる
• 純粋仮装関数にはabstractキーワードを先頭につける
• <要検討>デフォルト実装を書くことを許す（本当は許さない方が厳密なinterfaceなんですけど）

1 2 3 4 5 6 7

- | | | | !

interface IButtonListener { // 抽象関数（絶対実装） abstract void onButtonPush( in IButton sender )const; // デフォルト実装ありの関数 void onButtonFocused( in IButton sender )const{} };

class

• 強制的にobject型を継承している
• 他の言語でよくあるclassの継承は不可 -> C#のような１つだけ継承できるのはしてもいいんじゃないかと思い始めてる最近
• interfaceは何個でも継承できる

pod

• plain object data
• C言語のstructに近い
• デフォルトコンストラクタはオブジェクトのメモリ領域を0で初期化する扱いになる

struct

• 継承のないC++のクラス・D言語のscope classと同じ
• ガベージコレクト対象ではないので，structなオブジェクトインスタンスの参照（オブジェクトハンドル）を保持することができない

utility

• static関数のみ提供する型，インスタンスを作ることができない。

メンバ公開修飾子 - public private(class,struct)

• protectedは無い。
• デフォルトはpublic
• コロンを使うC++スタイル、メンバ変数・関数に直接記述するJAVAスタイルの両方に対応

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

- | | | | | | | | | | | !

class A { //--- 公開修飾子（デフォルトpublic） // C++/Dスタイル public: void funcPubA(){} // public private: void funcPriA(){} // private // JAVA/C#/Dスタイル public void funcPubB(){} // public private void funcPriB(){} // private };

オーバーライドチェック - override(class)

• D,C#と同じ

不変条件 - invariant(class,pod,struct)

• (all)Dのinvariantとほぼ同じ
  • 呼び出されるタイミング
    • publicなメンバ関数の実行直前・直後
    • ↑ publicメンバ変数によって自動で作成される関数も対象に含む。（メンバ変数の項を参照）
    • コンストラクタの直後
    • デストラクタの直前
  • invariant関数内でpure constメンバ関数以外のメンバ関数を呼び出すことを禁止。
• <要検討>structで再帰呼び出しされたらどうしよう（classはカウンタ持たせればいいかな）
  • ↑これってどういう意味だっけ；

委譲 (class)

• interfaceのデフォルト実装を別オブジェクトに委譲する

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

- | | ! - | | ! - | | | | | | ! - | | | | !

interface IButtonListener { abstract void onPushed(); void onFocused(){} }; class Hoge : IButtonListener { public: override void onPushed(){} }; class A : IButtonListener = mHoge { // IButtonListenerの関数を全てmHogeに委譲される // implementを使うと自動で次のように展開される // override void onPushed(){ mHoge.onPushed(); } // override void onFocused(){ mHoge.onFocused(); } private: Hoge@ mHoge; }; class B : public IButtonListener = mHoge { // onFocusedの関数だけ実装、その他はmHogeにまかせる override void onFocused() { /* */ } private: Hoge@ mHoge; };

コンストラクタ - this() (class,pod,struct)

• (all)D言語の形式を採用し、関数名はthisを使う
• (all)別コンストラクタ関数コールは可能
• (all)どのコンストラクタよりも前に.Initデータをメモリ領域にセットされる（D言語と同じふるまいをする）
• (pod)デフォルトコンストラクタは定義できない（0初期化固定）
  

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  - | | - | ! | | - | | ! | | | !

  class A { public: this() { mY = mX + 1; } this(in int x, in int y) : this() { mX = x; mY = y; } int mX = 1; // 直接初期化子を書くことが出来る。ただし，コンパイル時に決まる定数しか書けない。 int mY; // 指定がないとデフォルトコンストラクタが呼ばれる。 };

デストラクタ - ~this() (class,struct)

• D言語スタイルを採用

  0
  1
  2
  3
  4
  5

class A
{
public:
    ~this()
    {
    }
};

静的コンストラクタ - static this() (class,struct,pod,utility)

• D言語と同じ
• 静的コンストラクタが呼ばれる前に，.initデータがメモリ領域にコピーされる。

  0
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11

class A
{
    static int hoge = 1;
    static int foo; // hoge * 2を代入したいが，他の変数を参照することができない
    
    static this()
    {
        // この時点で，.initデータがコピー済み。
        // つまり，hogeには1，fooには0(デフォルト値)が代入済み
 
        foo = hoge * 2; // ここなら他の変数を参照することができる。
    }
};

静的デストラクタ - static ~this() (class,struct,pod,utility)

• D言語と同じ

  0
  1
  2
  3
  4

class A
{
    static ~this()
    {
    }
};

静的メンバ関数 (class,interface,pod,struct,utility)

• D言語と同じ。

静的メンバ変数 (class,pod,struct)

• D言語と同じ。

メンバ関数 (class,interface,struct,pod）

• (all)C++でいうメンバ関数のconst修飾子はあり。引数リストの括弧の後ろにconstを付ける。
• (class)抽象関数にoverrideキーワードが使える
• (interface)純粋仮装関数には先頭にabstractキーワードを付ける
• (interface)デフォルト実装はstatic関数として同じ名前の関数が定義される。

1 2 3 4 5 6 7

- | | | | !

interface IName { string getName(){ return "NoName"; } // こう書くと自動でstatic関数が作られる // static string getName() { return "NoName"; } // IName.DEFAULT.getName( IName )でアクセスできる };

メンバ変数 (class,struct,pod)

• publicなメンバ変数は関数に展開される。
• こうすることで変数のオフセット情報を知る必要がなくなり，再コンパイルの回数を減らすことができる。
  

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

  - | | | | | | | | | | | | - | | | | | | | | | | | | | | ! !

  struct Hoge { public int a; // これは下記のように展開される // public ref int __mv_ref_a() // { // return a; // } // public const ref int __mv_ref_a()const // { // return a; // } static void test() { Hoge h; h.a = 3; // h.__mv_ref_a() = 3; に展開される h.a = Hoge().a + Hoge().a; // 展開後 // { // Hoge __tv00; // Hoge __tv01; // h.__mv_ref_a() = __tv00.__mv_ref_a() + __tv01.__mv_ref_a(); // } h.a += 3; // 展開後 // h.__mv_ref_a() += 3; } }

inlineメンバ変数

1 2 3 4 5 6 7 8 9

- | | | | !

class Hoge { public inline Foo@ a; // こうするとメンバ変数にダイレクトにアクセスするようになる。 // invariantメソッドが実装されていても呼ばれなくなる。 // Fooのメンバ変数の構成が変更されると再コンパイルが必要になる。 };