4

継承でこれを行うことができることは知っていますが、「is a」状況を除いて継承を使用することを意図しています。友達がいることも知っていますが、プライベートメンバーへのアクセスも許可しています。

これを行う方法はありますか (プライベート メンバーではなく、クラスの保護されたメンバーへのアクセスを許可する)?

質問を言い換えると、クラス 1 とクラス 2 があります。クラス 2 がクラス 1 の保護されたメンバーとパブリック メンバーにアクセスできるようにしたいのですが、それはプライベート メンバーではありません。どうすればいいですか？

4

3 に答える 3

5

エレガントではありませんが、これはうまくいくかもしれません：

class B;

class A {
protected:
    int x;
private:
    int y;
};

class A_wrapper : public A {
    friend B;
};


class B {
public:
    A_wrapper a;
    int foo() {
        a.x;   // Ok
        a.y;   // Compiler error!
    }
};
于 2012-04-23T08:40:21.527 に答える
2

昔、まさにこのウェブサイトで、私は を使ったスキームを提示しましたKey。インターフェイスのどの部分がパブリックにアクセス可能で、どの部分がキーを必要とするかをメイン クラスが文書化し、キーを必要とする人にそのキーへのフレンドシップを付与するという考え方です。

class Key { friend class Stranger; Key() {} ~Key() {} };

class Item {
public:
    void everyone();

    void restricted(Key);
private:
};

現在、ここに示されているように、メソッドのみStrangerを使用できます。restricted

class Stranger {
public:
    void test(Item& i) {
        Key k;
        i.restricted(k);
    }

    Key key() { return Key(); }

    Key _key;
};

class Other {
    void test(Item& i) {
        Stranger s;
        i.restricted(s.key()); // error: ‘Key::~Key()’ is private
                               // error: within this context
    }

    void test2(Item& i) {
        Stranger s;
        i.restricted(s._key); // error: ‘Key::~Key()’ is private
                              // error: within this context
                              // error:   initializing argument 1 of ‘void Item::restricted(Key)’
    }
};

これは非常に単純なスキームであり、完全な友情よりもはるかにきめ細かいアプローチを可能にします。

于 2012-04-23T11:24:54.163 に答える
1

Oli'sはより近い解決策（+1）を提供しましたが、選択的な友人を使用してそれにアプローチすることもできます。

#include <iostream>

class t_thing;

class t_elsewhere {
public:
    void print(const t_thing& thing);
};

class t_thing {
public:
    class t_selective_friend {
        static int Prot(const t_thing& thing) {
            return thing.prot;
        }

        friend class t_elsewhere;
    };
public:
    int publ;
protected:
    int prot;
protected:
    int priv;
};

void t_elsewhere::print(const t_thing& thing) {
    std::cout << t_thing::t_selective_friend::Prot(thing) << std::endl;
}

int main() {
    t_thing thing;

    thing.publ; /* << ok */
    thing.prot; /* << error */
    thing.priv; /* << error */
    t_elsewhere().print(thing); /* << ok */
    return 0;
}

時々、その冗長性/制御が良い…</ p>

于 2012-04-23T08:48:00.420 に答える