Why can't '='(Assignment) operator be overloaded as friend function ?

Discussion in 'C++' started by Nitin Bhardwaj, Jul 11, 2003.

  1. Thanx in advance for the response...

    I wanna enquire ( as it is asked many a times in Interviews that i
    face as an Engg PostGraduate ) about the overloading capability of the
    C++ Language.

    Why can't the = (assignment) operator be overloaded as a friend
    function ?
    I work in VS 6.0 ( Win2000 ) as when i referred the MSDN documen'n it
    said the following :

    The operators [] , -> , = cannot be overloaded as static functions

    from which i figured out that since 'friend' qualifier makes the
    function a static function( i.e. a per-class member ), hence =
    operator can't be overloaded as a friend function.But why is such
    restrction there in the language in the first place ???
    Nitin Bhardwaj, Jul 11, 2003
    1. Advertisements

  2. Nitin Bhardwaj

    Jan Rendek Guest

    1) If you do not define an assignment operator in your class
    Sorry I did not finish that one:
    The created default operator definition
    will result in an ambigous call whenever
    you'll use the assignment

    class A {

    A(int i) : _i(i) {}

    friend A& operator=(A& lhs, const A& rhs);

    int i;

    A& operator=(A& lhs, const A& rhs) {
    lhs._i = rhs._i;

    int main() {
    A a(0), b(10);

    a = b;
    leads to the following error msg: (GCC 3.2, Linux Mandrake 9.0, Intel

    See the *** line

    launcher.C:11: `A& operator=(A&, const A&)' must be a nonstatic member
    launcher.C:18: `A& operator=(A&, const A&)' must be a nonstatic member

    launcher.C: In function `int main()':
    launcher.C:25: ambiguous overload for `A& = A&' operator ***
    launcher.C:6: candidates are: A& A::eek:perator=(const A&)
    launcher.C:18: A& operator=(A&, const A&)
    launcher.C:18: A& operator=(A&, const A&)
    Jan Rendek, Jul 11, 2003
    1. Advertisements

  3. Different rules apply to the functions which are called because they are
    member functions or friend functions. For instance

    class X // uses friend
    X(int); // note we can make an X from an int
    friend bool operator<(const X&, const X&);

    Given the above

    X x;
    if (1 < x)

    is legal. The compiler will automatically construct an X object from the int
    1. But given

    class Y // uses member
    Y(int); // note we can make an Y from an int
    bool operator<(const Y&) const;


    Y y;
    if (1 < y)

    is not legal. With a member function you do not get the automatic conversion
    of the first argument, the compiler will not construct a Y object from an
    int in the expression 1 < y.

    You can probably guess what is coming now. If you were able to declare
    operator= as a friend like this

    class X // uses friend
    X(int); // note we can make an X from an int
    X& operator=(X&, const X&);

    then stupid code like this

    X x;
    1 = x;

    would be legal!

    In short requiring that operator= be a member function ensures that what you
    are assigning to really is a bona fide object, not some temporary
    constructed by the compiler.

    John Harrison, Jul 11, 2003
  4. Of course I meant

    friend X& operator=(X&, const X&);

    John Harrison, Jul 11, 2003
  5. Nitin Bhardwaj

    Ron Natalie Guest

    The copy assignment operator is generated by the compiler if you don't define
    one for a class. If you try to implement it as a non-member function, it doesn't
    supress the generated one.
    Ron Natalie, Jul 11, 2003
  6. Wouldn't the above fail to compile? If the lhs is a temporary, it wouldn't
    bind to the non-const-reference first parameter of the operator=.


    Stuart Golodetz, Jul 11, 2003
  7. I guess the real question that was meant by the above wording is why
    copy assignment operator cannot be overloaded by a standalone
    (non-member) function.

    The short answer is because the C++ standard does not allow it. The
    longer answer should probably include the rationale that lead to this

    The rationale is as follows. Since the compiler always provides an
    implicit declaration of copy assignment operator for a class that
    doesn't declare one explicitly, later declaration of standalone copy
    assignment operator would change the meaning of the assignment in the
    middle of the translation unit:

    class A {
    /* no assignment operator explicitly declared */

    void foo() {
    A a, b;
    a = b; // this invokes the implicitly declared assignment

    A& operator =(A& lhs, const A& rhs);

    void bar() {
    A a, b;
    a = b; // this invokes the user-declared assignment

    Note that moving the definition of function 'bar' to some point above
    the declaration of the assignment operator would change its meaning.
    This behavior was considered to be potentially dangerous (and it is).

    For this reason, the copy assignment operator is not permitted to be
    overloaded by a standalone function in C++.
    Andrey Tarasevich, Jul 11, 2003
  8. Nitin Bhardwaj

    vijay Guest

    The reason why a = assignment operator function can't be static is , when u
    right that , u need to have a this pointer for reason one that u need to
    elimite the possiblibity of self assignment
    for this u need a this pointer and this pointer is not passed by default in
    static fuinctions

    vijay, Jul 14, 2003
  9. There is absolutely no need to have a 'this' pointer to eliminate
    self-assignment. As long as you can obtain and compare addresses of
    actual lhs and rhs objects, you can easily detect and eliminate

    It has nothing to do with 'this' pointer.
    Andrey Tarasevich, Jul 14, 2003
    1. Advertisements

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments (here). After that, you can post your question and our members will help you out.