C++，C++/CX に挑戦！

// ------------------------------------
#include <iostream>
using namespace std;

class Aaa {                 // ◆基底クラス
    int a;
public:
    Aaa(int n = 10)
        : a(n) { }
    int get_a() const { return a; }
    void set_a(int n) { a = n; }
};

class Bbb : public Aaa {    // ◆派生クラス
    int b;
public:
    Bbb(int n = 30)
        : Aaa(n), b(99) { }
    int get_b() const { return b; }
};

void twice(Aaa& x) {    /* ★１ */
    int n = x.get_a();
    x.set_a(2 * n);
}

int main() {
    Aaa a1;
    Bbb b1;

    cout << a1.get_a() << '\n';
    cout << b1.get_a() << '\n';

    twice(a1);
    twice(b1);          /* ★２ */

    cout << a1.get_a() << '\n';
    cout << b1.get_a() << '\n';

    int (Aaa::*ptr)()const;             /* ★３ */
    // クラス Aaa のメンバ関数へのポインタ ptr の宣言
    ptr = &Aaa::get_a;
    // ポインタ ptr がメンバ関数 get_a を指すように設定
    cout << (b1.*ptr)() << '\n';        /* ★４ */

    Aaa* ptr2;                          /* ★５ */
    // Aaa*型のポインタ ptr2 の宣言
    ptr2 = &b1;
    // ポインタ ptr2 がメンバオブジェクト b1 を
    //                                   指すように設定
    cout << (*ptr2).get_a() << '\n';    /* ★６ */
}
// ------------------------------------

// ------------------------------------
#include <iostream>
using namespace std;

class Array {                   /* ◆基底クラス */
    const int num = 5;
    int *p;

public:
    char chr;
    Array() : p(new int[num]) {
        cout << "デフォルトコンストラクタ(領域確保)\n";
    }
    // ↑デフォルトコンストラクタ
    //      要素数 num の int型配列用領域を確保

    Array(const Array& x) : p(new int[x.num]) {
        for (int i = 0; i < num; i++) p[i] = x.p[i];
        cout << "コピーコンストラクタ\n";
    }
    // ↑コピーコンストラクタ

    ~Array() {
        delete[] p;
        cout << "デストラクタ, chr … " << chr << '\n';
    }
    // ↑デストラクタ

    Array& operator=(const Array& x) {
        cout << "代入演算子\n";
        for (int i = 0; i < num; i++)
            p[i] = x.p[i];
        return *this;
    }
    // ↑代入演算子


    void set(int v) {
        for (int i = 0; i < num; i++) p[i] = v;
    }
    // ↑メンバ関数
    //      全要素に値 v を代入

    void print() const {
        for (int i = 0; i < num; i++) cout << p[i] << ' ';
    }
    // ↑メンバ関数
    //      全要素の値を表示
};


class ArrayX : public Array {   /* ◆派生クラス */
    int k;
public:
    int get_k() const { return k; }
    void set_k(int x) { k = x; }
};
// コンストラクタ，コピーコンストラクタ，デストラクタ
//                                 の定義はしていない。

int main() {
    ArrayX a;       // ArrayX a を作成
    /* ↑デフォルトコンストラクタが作動 */
    a.set(10);      // aの全要素に 10 を代入
    a.set_k(99);    // a.k に 99 を代入

    ArrayX b(a);    // ArrayX b を作成(aで初期化)
    /* ↑コピーコンストラクタが作動 */

    ArrayX c;       // ArrayX c を作成
    /* ↑デフォルトコンストラクタが作動 */
    c = a;
    /* ↑代入演算子が作動(aの全要素をcにコピー) */

    a.chr = 'a'; b.chr = 'b'; c.chr = 'c';

    cout << '\n';
    cout << "配列a : "; a.print();   cout << '\n';
    cout << "     k : " << a.get_k() << '\n';
    cout << "配列b : "; b.print();   cout << '\n';
    cout << "     k : " << b.get_k() << '\n';
    cout << "配列c : "; c.print();   cout << '\n';
    cout << "     k : " << c.get_k() << '\n';
    cout << '\n';
}
// ------------------------------------

// ------------------------------------
#include <iostream>
using namespace std;

// クラス Derived の基底クラス
class Base {
    int x;
public:
    Base(int a = 0) : x(a) {
        cout << "Base::x を" << x << "で初期化。\n";
    }
};

// クラス Derived にメンバとして含まれるクラス
class Memb {
    int x;
public:
    Memb(int a = 0) : x(a) {
        cout << "Memb::x を" << x << "で初期化。\n";
    }
};

// 派生クラス Derived を生成
//           (基底クラス Base から public派生)
class Derived : public Base {
    int y;
    Memb m1;
    Memb m2;
    void say() {
        y = 0;
        cout << "Derived::y を" << y << "で初期化。\n";
    }
public:
    Derived() { say(); }
    Derived(int a, int b, int c)
        : m2(a), m1(b), Base(c) {
        say();
    }
};

int main() {
    Derived d1;
    cout << '\n';
    Derived d2(1, 2, 3);
}

// *** 実行結果 ****************
// *  Base::x を0で初期化。    *
// *  Memb::x を0で初期化。    *
// *  Memb::x を0で初期化。    *
// *  Derived::y を0で初期化。 *
// *                           *
// *  Base::x を3で初期化。    *
// *  Memb::x を2で初期化。    *
// *  Memb::x を1で初期化。    *
// *  Derived::y を0で初期化。 *
// *****************************
// ------------

// p161_演習4-2
#include <iostream>
using namespace std;

// クラス Derived の基底クラス
class Base {
    int x;
public:
    Base(int a = 0) : x(a) {
        cout << "Base::x を" << x << "で初期化。\n";
    }
    ~Base() { cout << "デストラクタ ~Base, "
                   << "x = " << x << '\n';
    }
};

// クラス Derived にメンバとして含まれるクラス
class Memb {
    int x;
public:
    Memb(int a = 0) : x(a) {
        cout << "Memb::x を" << x << "で初期化。\n";
    }
    ~Memb() { cout << "デストラクタ ~Memb, " 
                   << "x = " << x << '\n'; }
};

// 派生クラス Derived を生成
//           (基底クラス Base から public派生)
class Derived : public Base {
    int y;
    Memb m1;
    Memb m2;
    void say() {
        y = 0;
        cout << "Derived::y を" << y << "で初期化。\n";
    }
public:
    Derived() { say(); }
    Derived(int a, int b, int c)
        : m2(a), m1(b), Base(c) {
        say();
    }
    ~Derived() { cout << "\nデストラクタ ~Derived, "
                      << "y = " << y << '\n';
    }
};

int main() {
    Derived d1;
    cout << '\n';
    Derived d2(1, 2, 3);
}

// ------------------------------------
#include <iostream>
using namespace std;

class Base {
    int x;
public:
    Base() : x(99) { cout << "Base::x を 99 で初期化。\n"; }
    // ↑のコンストラクタを書きかえること。
    int get_x() const { return x; }
};

class Derived : public Base {
};

int main()
{
    Derived d;
    cout << "d.get_x() = " << d.get_x() << '\n';
}

// *** 実行結果 ******************
// *   Base::x を 99 で初期化。  *
// *   d.get_x() = 99            *
// *******************************
// ------------

// p159_演習4-1
#include <iostream>
using namespace std;

class Base {
    int x;
public:
    Base::Base(int xx = 99) : x(xx) {
        cout << "Base::x を " << x << " で初期化。\n";
    }
    int get_x() const { return x; }
};

class Derived : public Base {
};

int main()
{
    Derived d;
    cout << "d.get_x() = " << d.get_x() << '\n';
}

// ------------------------------------
#include <iostream>
using namespace std;

// 基底クラス C_base
class C_base {
    int a;
    int b;
public:
    C_base(int x, int y) : a(x), b(y) { }
    int get_a() const { return a; }
    int get_b() const { return b; }
};

// 派生クラス C_drvd
class C_drvd : public C_base {
    int k;
public:
    C_drvd(int x, int y, int z)
        : C_base(x, y), k(z) { }
    void disp() const {
        cout << "a = " << get_a()
             << ", b = " << get_b()
             << ", k = " << k;
    }
};

int main() {
    C_drvd d(1, 2, 3);
    d.disp();
    cout << '\n';
}
// ------------------------------------

// ----------------------------
// 基底クラス C_base
class C_base {
    int a;
public:
    C_base(int x) : a(x) { }

// 派生クラス C_drvd
class C_drvd : public C_base {
    int k;
};                      // エラー
// ----------------------------

// ----------------------------
// 基底クラス C_base
class C_base {
    int a;
public:
    C_base(int x = 0) : a(x) { }
};

// 派生クラス C_drvd
class C_drvd : public C_base {
    int k;
};                      // 大丈夫
// ----------------------------

// ------------------------------------
#include <iostream>
using namespace std;

// 基底クラス Base
class Base {
    int x;
public:
    Base() : x(99) { }
    int get_x() const { return x; }
    void set_x(int n) { x = n; }
};

// 派生クラス Derived
class Derived : private Base {   // private派生
// private派生の場合、基底クラス Base の publicメンバ
//     は、派生クラス内では、privateメンバになります。
public:
    int y;
    int get_x_() const { return get_x(); }
    // 基底クラス Base の publicメンバ関数は､派生クラ
    //        ス内では private になってしまいますから､
    //        利用者は get_x関数 や set_x関数を使うこ
    //        とができません。
    // 利用者が､データメンバ x の値を知る必要があるな
    //        ら、そのためのゲッタが必要です。

    void set_x_(int n) { set_x(n); }
    // 利用者が､データメンバ x に値をセットするための
    //        セッタです。
};

int main()
{
    Derived d;

    cout << d.get_x_() << '\n';                  // 99
    d.set_x_(10);
    cout << d.get_x_() << '\n';                  // 10
    d.y = 20;
    cout << d.y << '\n';                         // 20
    cout << d.get_x_() << " " << d.y << '\n'; // 10 20

    Base b;

    cout << b.get_x() << '\n';                   // 99

//  b = d;    // 不可
// アクセスできない基底クラス Base への変換は許可され
//                                         ていません。
}
// ------------------------------------

// ------------------------------------
#include <iostream>
using namespace std;

// 基底クラス Base
class Base {
    int x;
public:
    Base() : x(99) { }
    int get_x() const { return x; }
    void set_x(int n) { x = n; }
};

// 派生クラス Derived
class Derived : public Base {
// Baseクラスを親クラスとして､子クラス Derived を作成。
// public派生なので、基底クラス Base のpublicメンバは、
//     派生クラス Derived においても publicメンバです。
public:
    int y;
    // 派生クラス Derived 独自のデータメンバです。
};

int main()
{
    Derived d;

    cout << d.get_x() << '\n';                   // 99
    // Baseクラスの公開メンバ関数 get_x は、
    //    派生クラス Derived の公開メンバ関数です。

    d.set_x(10);
    // データメンバ x に値をセット。
    // Baseクラスの公開メンバ関数 set_x は、
    //    派生クラス Derived の公開メンバ関数です。

    cout << d.get_x() << '\n';                   // 10
    // 値が変更されています。

    int Derived::*ptr = &Derived::y;
    d.*ptr = 20;
    // Derivedクラスには、データメンバ y 用のセッタが
    //   ないので、Derived::y へのポインタ ptr を利用
    //   して、y に値をセット。
    // y は publicメンバなので、単に
    //   d.y = 20;
    // とするだけでいいのに､ちょっと前回《167》の復習
    //               をしてみたかったので･･･ (*^^*)ゞ

    cout << d.y << '\n';                         // 20
    // 値が変更されています。

    cout << d.get_x() << " " << d.y << '\n';  // 10 20
    // 現時点での x, y の値です。

    Base b;
    // Base型のクラス b を作りました。

    cout << b.get_x() << '\n';                   // 99
    // Base のコンストラクタの設定通りの値です。

    b = d;
    // 基底クラス(親クラス) Base のオブジェクト b に､
    //    派生クラス(子クラス) Derived のオブジェクト
    //    d を代入します。
    //    b と d は型が違うのですが、大丈夫です。

    cout << b.get_x() << '\n';                   // 10
    // Base のコンストラクタの設定通りの値だったのが､
    //     オブジェクト d のデータメンバ x の値に変更
    //     されています。
    // b = d; は可能ですが、
    // d = b; はできません。 d.y に何を代入したらいい
    //     のかが分からないからです。
}
// ------------------------------------

// ------------------------------------
#include <iostream>
using namespace std;

class C {
public:
    static int n;               // 静的データメンバ
    static void func() {        // 静的メンバ関数
        std::cout << "static void func();\n";
    }
    int a;                      // 通常のデータメンバ
    int get_a() const{ return a; }
                                // 通常のメンバ関数
    C() { a = 1000; }           // コンストラクタ
};

int C::n = 9999;
// 静的データメンバの実体は、クラス定義の外で
//                      static を付けずに定義する。

int main()
{
    C test;

    int *ptr1 = &C::n;
    // 静的データメンバへのポインタ
    void(*ptr2)() = &C::func;
    // 静的メンバ関数へのポインタ
    int C::*ptr3 = &C::a;
    // 通常のデータメンバへのポインタ
    int (C::*ptr4)() const= &C::get_a;
    // 通常の静的メンバ関数へのポインタ

    cout << *ptr1 << '\n';
    (*ptr2)();
    cout << test.*ptr3 << '\n';
    cout << (test.*ptr4)() << '\n';
}
// ------------------------------------

【 クラス person 】
class Person {
public:
    char name[10];          // 名前
    int  height;            // 身長
    int  weight;            // 体重
};

【 Person型の配列 】
    Person x[]= {{"Shibata",  170, 52},
                 {"Takaoka",  180, 70},
                 {"Nangoh",   172, 63},
                 {"Sugiyama", 165, 50},
                };

// p135_演習3-14
#include <iomanip>
#include <cstdlib>
#include <iostream>
using namespace std;

class Person {
public:
    char name[10];          // 名前
    int  height;            // 身長
    int  weight;            // 体重
};

// x, yの指すnバイトの領域を交換する関数。
namespace {
    void memswap(void* x, void* y, size_t n)
    {
        unsigned char* a = reinterpret_cast<unsigned char*>(x);
        unsigned char* b = reinterpret_cast<unsigned char*>(y);

        for (; n--; a++, b++) {
            unsigned char c = *a;
            *a = *b;
            *b = c;
        }
    }
}

void quicksort(void* base, size_t nmemb, size_t size,
    int(*compar)(const void*, const void*))
{
    if (nmemb > 0) {
        const char* v = reinterpret_cast<const char*>(base);
        // 配列 base の先頭要素へのポインタ v
        size_t pl = 0;              // 探索範囲左端の位置（添字）
        size_t pr = nmemb - 1;      // 探索範囲右端の位置（添字）
        size_t pv = nmemb;          // 基準値の位置（添字）
        size_t pt = (pl + pr) / 2;  // 更新後の基準値の位置（添字）

        do {
            const char* x = &v[pt * size];
            // const char*型のポインタ x 
            //      関数内の配列 v の各要素を指すポインタ用の変数です。
            //      v[pt * size] は 基準値 base[pt] に対応します。

            if (pv != pt) x = &v[(pv = pt) * size];
            // 基準値の位置に変更があった場合は、更新します。

            while (compar(reinterpret_cast<const void*>(&v[pl * size]), x) < 0)
                pl++;
            // 探索範囲左端からチェックしていき、基準値のほうが大きければ、
            //      探索範囲左端の位置 pl をインクリメント。
            //      基準値以上の値を見つけたら、pl はその値の位置で止まります。

            while (compar(reinterpret_cast<const void*>(&v[pr * size]), x) > 0)
                pr--;
            // 探索範囲右端からチェックしていき、基準値のほうが小さければ、
            //      探索範囲右端の位置 pr をデクリメント。
            //      基準値以下の値を見つけたら、pr はその値の位置で止まります。

            if (pl <= pr) {
                // 探索範囲の左端と右端が逆転していないうちは･･･
                pt = (pl == pv) ? pr : (pr == pv) ? pl : pv;
                // 探索範囲の左端が基準値の位置に達している場合は、基準値の位置
                //      を現時点での右端の位置に更新します。
                // 探索範囲の右端が基準値の位置に達している場合は、基準値の位置
                //      を現時点での左端の位置に更新します。
                // それ以外なら、基準値の位置は更新しません。
                // ※以上の操作は、memswap関数が値を交換しても基準値の値が変化
                //      しないようにするため。

                memswap(const_cast<void*>(reinterpret_cast<const void*>(&v[pl * size])),
                    const_cast<void*>(reinterpret_cast<const void*>(&v[pr * size])),
                    size);
                pl++;
                if (pr == 0)    // 符号無し整数 0 からのデクリメントを避ける。
                    goto QuickRight;
                pr--;
            }
        } while (pl <= pr);
        // 配列 base は、do文が終了すると、quicksort関数内で最初に決めた
        //          基準値 base[pt] に対してその値以上の部分と以下の部分に分けられます。

        if (0 < pr)
            // do文で二つに分けられた区間の左側を対象にして、
            //                      quicksort関数を再帰的に呼び出します。
            quicksort(const_cast<void*>(reinterpret_cast<const void*>(&v[0])),
                pr + 1, size, compar);
    QuickRight:
        if (pl < nmemb - 1)
            // do文で二つに分けられた区間の右側を対象にして、
            //                      quicksort関数を再帰的に呼び出します。
            quicksort(const_cast<void*>(reinterpret_cast<const void*>(&v[pl * size])),
                nmemb - pl, size, compar);
    }
}

int acmp(char* x, char* y) {
    // 比較関数 : 配列による文字列用
    return strcmp(x, y);
}

int pcmp(char** x, char** y) {
    // 比較関数 : ポインタによる文字列用
    return strcmp(*x, *y);
}

int ncmp(int* x, int* y) {
    // 比較関数 : int型の整数用
    return *x < *y ? -1 :
        *x > *y ? 1 : 0;
}

int npcmp(const Person* x, const Person* y) {
    // 比較関数 : Person型の名前メンバ用
    return strcmp((*x).name, (*y).name);
}

int hpcmp(const Person* x, const Person* y) {
    // 比較関数 : Person型の身長メンバ用
    return (*x).height < (*y).height ? -1 :
        (*x).height >(*y).height ? 1 : 0;
}

int wpcmp(const Person* x, const Person* y) {
    // 比較関数 : Person型の体重メンバ用
    return (*x).weight < (*y).weight ? 1 :
        (*x).weight >(*y).weight ? -1 : 0;
}

void print_person(const Person x[], int no) {
    // Person型データを一覧表示
    for (int i = 0; i < no; i++)
        cout << setw(10) << left << x[i].name << " "
        << x[i].height << "cm " << x[i].weight << "kg\n";
}


int main()
{
    Person x[] = { { "Shibata",  170, 52 },
    { "Takaoka",  180, 70 },
    { "Nangoh",   172, 63 },
    { "Sugiyama", 165, 50 },
    };

    int nx = sizeof(x) / sizeof(x[0]);

    puts("ソート前");
    print_person(x, nx);

    // 名前昇順にソート
    quicksort(x, nx, sizeof(Person),
        reinterpret_cast<int(*)(const void*, const void*)>(npcmp));

    cout << "\n名前昇順ソート後\n";
    print_person(x, nx);

    // 身長昇順にソート
    quicksort(x, nx, sizeof(Person),
        reinterpret_cast<int(*)(const void*, const void*)>(hpcmp));

    cout << "\n身長昇順ソート後\n";
    print_person(x, nx);

    // 体重降順にソート
    quicksort(x, nx, sizeof(Person),
        reinterpret_cast<int(*)(const void*, const void*)>(wpcmp));

    cout << "\n体重降順ソート後\n";
    print_person(x, nx);
}

// ------------------------------------
#include <iostream>

class C {
public:
    char chr;
    C() { chr = 'a'; }
    char ch() { return chr; }
};

C c;// C型のクラスオブジェクト c を作る。

int main() {
    char C::*ptr_c;     // データメンバへのポインタ ptr_c の宣言
    char (C::*ptr_f)(); // メンバ関数へのポインタ   ptr_f の宣言

    ptr_c = &C::chr;
    // ポインタ ptr_c がデータメンバ C::chr を指すように設定
    ptr_f = &C::ch;
    // ポインタ ptr_f がメンバ関数 C::ch を指すように設定

    std::cout << (c.*ptr_f)() << '\n';
    // std::cout << c.ch() << '\n'; と同じこと
    c.*ptr_c = 'b';
    // c.chr = 'b'; と同じこと
    std::cout << (c.*ptr_f)() << '\n';
}
// ------------------------------------

// ------------------------------------
// SimpleDate.h ヘッダファイル
#ifndef ___Class_SimpleDate
#define ___Class_SimpleDate

class SimpleDate {
    int y;      // 西暦年
    int m;      // 月
    int d;      // 日

public:
    SimpleDate(int yy = 1, int mm = 1, int dd = 1)
                            : y(yy), m(mm), d(dd) { }

    int year()  const { return y; }
    int month() const { return m; }
    int day()   const { return d; }

    int comp_y(int yy) const { return yy - y; }
    // yyから年を減じた値を返却
    int comp_m(int mm) const { return mm - m; }
    // mmから月を減じた値を返却
    int comp_d(int dd) const { return dd - d; }
    // ddから日を減じた値を返却
};

#endif

// ------------

// SimpleDateTest.cpp ファイル
#include <iostream>
#include "SimpleDate.h"
using namespace std;

int main() {
    typedef int (SimpleDate::*Comp)(int) const;
    Comp pcomp[] = {
        &SimpleDate::comp_y,
        &SimpleDate::comp_m,
        &SimpleDate::comp_d,
    };
    int menu;
    const SimpleDate birthday(1963, 11, 18);

    cout << "私の誕生日を当ててください。\n";

    do {
        cout << "0…年/1…月/2…日/3…終了："; cin >> menu;

        if (menu >= 0 && menu <= 2) {
            int value;
            cout << "いくつかな："; cin >> value;

            int diff = (birthday.*pcomp[menu])(value);
            if (!diff)
                cout << "正解です。\n";
            else if (diff > 0)
                cout << diff << "だけ大きいです。\n";
            else
                cout << -diff << "だけ小さいです。\n";
        }
    } while (menu != 3);
}
// ------------------------------------

// p133_演習3-13
// 問題で指定された仕様に変更した SimpleDateTest.cppプログラム
#include <iostream>
#include "SimpleDate.h"
using namespace std;

int main() {
    typedef int (SimpleDate::*Comp)(int) const;
    Comp pcomp[] = {
        &SimpleDate::comp_y,
        &SimpleDate::comp_m,
        &SimpleDate::comp_d,
    };
    const char* menu[] = { "年", "月", "日" };
    const SimpleDate birthday(1963, 11, 18);

    cout << "私の誕生日を当ててください。\n";

    for (int i = 0; i < 3; i++) {
        int value;
        do {
            cout << "◆ " << menu[i] << " を入力 : "; cin >> value;
            int diff = (birthday.*pcomp[i])(value);

            if (!diff) {
                cout << "正解です。\n";
                break;
            }
            else if (diff > 0)
                cout << diff << "だけ大きいです。\n";
            else
                cout << -diff << "だけ小さいです。\n";
        } while (1);
    } 
}

// ------------------------------------
#include <iostream>
using namespace std;

class C {
    int num1;
    int num2;
public:
    C() { num1 = 100; num2 = 200; }
    int get_n1() const { return num1; }
    int get_n2() const { return num2; }
};

C c;

int f1(int (C::*get)() const);
int f2(int (C::*get)() const);
int func(int(*f)(int (C::*)() const), int (C::*get)() const);

int main() {
    cout << func(f1, &C::get_n1) << '\n';     // �@
    // func(f1, &C::get_n1) … 関数 func を呼び出します。
    // 引数 f1 は関数 f1 へのポインタです。関数名は、その関数へのポインタと解釈されます。
    // 引数 &C::get_n1 は、クラス C のメンバ関数 get_n1 へのポインタです。
    cout << func(f1, &C::get_n2) << '\n';
    cout << func(f2, &C::get_n1) << '\n';
    cout << func(f2, &C::get_n2) << '\n';
}

int func(int(*f)(int (C::*)() const), int (C::*get)() const) {
    // �@で呼び出された場合は･･･
    // 仮引数の f が、ポインタ f1 を受け取ります。
    // 仮引数の get が、 get_n1 へのポインタを受け取ります。

    return (*f)(get);
    // �@で呼び出された場合は･･･
    // *f は *f1 なので、関数 f1 を呼び出します。 
    //         引数 get は、仮引数が受け取った get です。
    // 関数 f1 からの返却値を、main関数に return します。
}

int f1(int (C::*get)() const) {
    // �@で呼び出された関数 func から呼び出された場合は･･･
    // クラス C のメンバ関数 get_n1 へのポインタを、仮引数 get が受け取ります。

    return (c.*get)();
    // クラスオブジェクト c のメンバ関数 get_n1 を呼び出します。
    // 間接ドット演算子「 .* 」を利用しています。
    // メンバ関数 get_n1 からの返却値を関数 f1 に return します。 
}

int f2(int (C::*get)() const) {
    return (c.*get)() * 100;
}
// ------------------------------------