0

私はいくつかのコードを調べていますが、このクラス ヘッダー ファイルでフレンド オペレーターが何をしているのか疑問に思っていました。

これは、「この演算子を使用していて、両方の入力が CSegment3D 型である場合、関数の実装で定義された方法で操作する」と言うだけでよいのでしょうか?

class CSegment3D : public CObject
{
public:
    CSegment3D& operator*=(const double& factor);//  multiply by a scalar factor & assign
    CSegment3D& operator/=(const double& factor);//  divide by a scalar factor & assign
    CSegment3D& operator+=(const CSegment3D& other);// vector addition
    CSegment3D& operator-=(const CSegment3D& other);// vector subtraction
    friend CSegment3D GetMidpoint(const CSegment3D& ptA, const CSegment3D& ptB);
    friend CSegment3D GetNormal( CSegment3D *pSeg1, CSegment3D *pSeg2, CSegment3D *pSeg3 ); // Return a point normal to the surface defines by the tree point passed in.
    friend double operator*(const CSegment3D& vectorA, const CSegment3D& vectorB); // dot product
    friend CSegment3D operator*(const double& factor, const CSegment3D& vectorA); // multiply by a scalar
    friend CSegment3D operator/(const CSegment3D& vectorA, const double& factor); // divide by a scalar
    friend CSegment3D operator+(const CSegment3D& vectorA, const CSegment3D& vectorB);// vector addition
    friend CSegment3D operator-(const CSegment3D& vectorA, const CSegment3D& vectorB );// vector subtraction
    friend CSegment3D operator^(const CSegment3D& vectorA, const CSegment3D& vectorB); // cross product
    friend CSegment3D operator%(CSegment3D vectorA, const CSegment3D& vectorB); // projection of vectorB onto vectorA
};
4

3 に答える 3

4

私がいつも生徒たちに言いたいことですが、友達はガールフレンドのようなものです: 友達のキーワードを持つ機能は家族ではありませんが、最も愛するもの、この場合は「プライベート」属性にアクセスできます。

于 2013-04-10T11:31:29.523 に答える
1

関数がそのクラスのメンバーではない場合でも、関数がクラスのプライベート メンバーにアクセスできるようにするために、キーワード friend が使用されます。フレンドシップはクラス定義内で宣言されますが、関数は依然としてそのクラスのメンバーではないため、別の場所で宣言および定義する必要があります。

たとえばfriend CSegment3D GetMidpoint(const CSegment3D& ptA, const CSegment3D& ptB);、クラス定義では、GetMidpoint(const CSegment3D& ptA, const CSegment3D& ptB)関数がそのクラスのメンバー関数でなくても、関数が CSegment3D のプライベート メンバーにアクセスできることを意味します。

于 2013-04-10T11:36:44.240 に答える
0

これは、より技術的な（そして退屈な）サンプル/回答です。

    // Point2D.h
    class Point2D() {
    private:
        float x,y;
    public:
                float GetX_Method() const;
                // Next one is a function, so cant add const at end
        friend  float GetX_FriendFunction(const Point2D &p); 
    }



    //Point2D.cpp

    float Point2D::GetX_Method() const {
        return x; // Since this method belongs to a point, C++ knows where to find x
    }


    float GetX_FriendFunction(const Point2D &p) {
        // This is a friend function. Itdoesn't belong to the class
        // but still can access private members of objects created from that
        // class. All we need is the object itself (p in this case)
        return p.x; 
    }

    // This one isn't either method nor friend
    float GetX_NoFriendFunction(const Point2D &p) {
        // This will give an error since x is private
        return p.x;
    }


    // main.cpp

    main() {
        Point2D p1;

        // Prints P1 X. P1 is implicitly given by calling function
        cout << p1.GetX_Method() << endl;        
        // Prints P1 X. P1 must be given as parameter 
        cout << GetX_FriendFunction(p1) << endl; 
        // This one throws error, since it can access private members of P1
        cout << GetX_NoFriendFunction(p1) << endl; 
    }


// NOTES: 
// * As you may guess, it's the class who says 'You're my friend', otherwise,
// anyone could access other's code and make bad things.
// 
// * If you abuse friendship, you'll end up working as with C and structs
// 
// * Typical use of friend are operators. For example, inside Point2D, you
// could write:


    // This one will allow us to multiply one float to both X and Y
    // and will be called this way:
    // 
    // p1 = p1 * 5.0f; // Also p1 = p1.operator*(5.0f);
    //
    // Notice operator* only accepts float number. Point is implicitly given
    Point2D operator*(float n); 

    // Now think about this one:
    //
    // p1 = 5.0f * p1;
    //
    // Mathematically it's the same, but following same rules than before,
    // you must go to "float" class to add the operator* function, which is,
    // of course, not possible :) so this is what you do
    friend Point2D operator*(float left_operator, const Point2D& right_operator);
    // That way, you use a friend function for do the same job


    // Anyway, as said, you must avoid using friend as much as possible.
    // This problem
    // 
    // p1 = 5.0f * p1;
    //
    // Could have been solved without using friend using a plain C function
    // like this:
    Point2D operator*(float left_operator, const Point2D& right_operator)
    {
        // Gotta love how easy is to get my work done by others in C++
        return right_operator*left_operator; 
    }
于 2013-04-12T12:27:27.213 に答える