0
Why a friend function cannot be used to overload the assignment operator?
Wiki User
∙ 11y ago
Assignment(=) operator is a special operator that will be provided by the constructor to the class when programmer has not provided(overloaded) as member of the class.(like copy constructor).
When programmer is overloading = operator using friend function, two = operations will exists:
1) compiler is providing = operator
2) programmer is providing(overloading) = operator by friend function.
Then simply ambiguity will be created and compiler will gives error. Its compilation error.
Wiki User
∙ 11y ago
Wiki User
∙ 11y agoobj1 = obj2;
Operator "=" can be overloaded either by the member function or by the friend operator function.
In case of the friend function, the obj1 and obj2 are should be from the different classes. If they are from the same class, the compilation error will occur. We can't use the "this" pointer in the friend function since it is not the member function of the class.
So,
If both objects are from the same class it is better to for operator function (operator=) as member function.
If the objects are from the different class, then the operator function as friend function is advisable.
Wiki User
∙ 11y agoBecause there's no way to designate the left-hand operand of an assignment via a friend function. The left-hand operand is a given when assignment is implemented as a member function.
Wiki User
∙ 11y ago* Assignment operator : =
* Function call operator : ()
* Subscripting operator : []
* Class member access operator.
Add your answer:
Earn +20 pts
Is sizeof an operator or function why?
You cannot overload the sizeof() operator because that could introduce uncertainty in its evaluation. The sizeof() operator must always produce an accurate and logically predictable result, thus all user-intervention is completely forbidden.
How will you overload a template function?
The only reason to overload a template function is to provide an overload that differs in the number and type of arguments that cannot be addressed by the template function alone. You simply declare them as you would any other overload. The overloads may themselves be template functions, but there must be no ambiguity: every template function must generate an unique function signature. Remember that template functions generate overloads at compile time on an as-required basis.
Operator original function in OOP C plus plus?
I'm not sure I fully understand the question. Operators and functions are not the same. However, many operators also have named alternatives implemented as functions, such that "add" is synonymous with the binary increment operator while "plus" is synonymous with the unary plus operator. However these are completely separate implementations that do the same thing such that the function implementation typically invokes the operator (with implicit inline expansion to factor away the unwanted function call). There is no way to determine the underlying function of an operator, nor the underlying operator of a function without having access to the implementation source code. Such implementation details cannot be accessed at compile time let alone runtime.
What are the disadvantages of scope resolution operator?
it cannot be operator overloaded.
Why do you use of operator overloading in c?
Overloading, Overriding, Polymorphism, Information Hiding, Inheritance all these are CONCEPTS of C++ and Java. An Object Oriented Language and not of C language. Thats why Bjarne Stroustrup came up with C++ ...
What is meant when you say you overload an operator?
All operators are built-in but not all operators can operate upon data types they know absolutely nothing about. There are some exceptions such as the new operator and the sizeof operator -- both will work on any datatype. However, for those that cannot, operator overloads allow you to cater specifically for those types. An operator overload is implemented just as you would overload a function, but it is not a function per se because operators have different calling conventions to functions. It is also important to keep in mind that just because you can overload an operator, it does not mean that you should. Operators should only be overloaded when the overload would allow a user to interact with your data type in an intuitive manner; a manner that is consistent with the operator's intended purpose. So while it can be amusing to overload the plus (+) operator to perform a subtraction (-), it could hardly be called intuitive. The assignment operator is the most overloaded operator of them all. This is because it is extremely useful to be able to copy the members of one object and assign those values to another object of the same type. We can also overload the assignment operator to cater for objects of different types, but such assignments are rarely intuitive. Does it make sense to assign the properties of a banana object to a person object? Probably not. Even if you could find a practical reason for doing so, would it be an intuitive operation? Definitely not. Therefore there's no point in providing an operator to cater for this. To create an operator overload, the declaration will often be placed inside the class it pertains to. However there are exceptions. The output stream insertion operator is a good example of this. The following example demonstrates how we can overload an internal operator (the assignment operator) as well as an external operator (output stream insertion operator). #include<iostream> // required to make use of I/O streams class A { private: unsigned m_data; public: // constructors... A (const unsigned data = 0): m_data (data) {} A (const A& copy): m_data (copy.m_data) {} // accessor function (interface) unsigned get_data() const { return m_data; } // operator overloads... A& operator= (const A& rhs) { m_data = rhs.m_data; } A& operator= (const unsigned rhs) { m_data = rhs; } }; std::ostream& operator<< (std::ostream& os, const A& a { os << a.get_data(); return os; } int main() { A a, b; // invoke default constructors a = 42; // call assignment operator overload b = a; // call default assignment operator overload // call insertion operator overload std::cout << a << std::endl; std::cout << b << std::endl; } Output: 42 42
How can you can create a new operator through operator overloading?
You cannot create any new operators in C++. You can only overload the existing ones (although some, such as sizeof, new and delete cannot be overloaded). The only way to create a new operator is to implement it as a standard function with a named identifier. For instance, sqrt() is the standard library function that provides the square root operator, for which no real operator exists.
What is the operator that cannot be overloaded in c plus plus and java?
conditional operator , size of operator , membership operator and scope resulation operator can not be overload in c++
Is sizeof an operator or function why?
You cannot overload the sizeof() operator because that could introduce uncertainty in its evaluation. The sizeof() operator must always produce an accurate and logically predictable result, thus all user-intervention is completely forbidden.
Why should you have to use comparison operator overloading in pairs in c?
You cannot overload operators in C. This is a C++ thing only.
What is the main function of an overload?
When a person has information overload, it means that they receive so much information at one time that their brain cannot process it all.
How will you overload a template function?
The only reason to overload a template function is to provide an overload that differs in the number and type of arguments that cannot be addressed by the template function alone. You simply declare them as you would any other overload. The overloads may themselves be template functions, but there must be no ambiguity: every template function must generate an unique function signature. Remember that template functions generate overloads at compile time on an as-required basis.
What is l value in c program?
An l-value is an expression with an address, named after being able to occur on the left side of the = (assignment) operator. (Technically, a variable declared with a const keyword is an l-value, but cannot occur on the left side of the assignment operator, so the original definition is no longer accurate.)
Operator original function in OOP C plus plus?
I'm not sure I fully understand the question. Operators and functions are not the same. However, many operators also have named alternatives implemented as functions, such that "add" is synonymous with the binary increment operator while "plus" is synonymous with the unary plus operator. However these are completely separate implementations that do the same thing such that the function implementation typically invokes the operator (with implicit inline expansion to factor away the unwanted function call). There is no way to determine the underlying function of an operator, nor the underlying operator of a function without having access to the implementation source code. Such implementation details cannot be accessed at compile time let alone runtime.
What are the disadvantages of scope resolution operator?
it cannot be operator overloaded.
Why do you use of operator overloading in c?
Overloading, Overriding, Polymorphism, Information Hiding, Inheritance all these are CONCEPTS of C++ and Java. An Object Oriented Language and not of C language. Thats why Bjarne Stroustrup came up with C++ ...
What is the purpose of 'this' operator in c?
Every instance of a class inherits a 'this' pointer. It always points to the instance itself. Outside of the object you must use the object's variable name to refer to the object, or instantiate a pointer to the object. But from within the object's member methods you must use the 'this' pointer which is instantiated automatically as soon as the object is constructed and falls from scope when the destructor returns. Only non-static member functions have access to the 'this' pointer. There are several uses, however the most important is when checking for self-references, particularly in the assignment operator overload. That is, any member function that accepts a reference to the same class of object should always check for self-references before attempting to mutate the instance. This is particularly important when the class "owns" memory that is dynamically allocated to it. It is also used to return a reference to the current instance from the assignment operator and from any other operator overload or function that must return a reference to the current instance (including the addition and subtraction operators). Both uses can be seen in the following stripped-down example: class MyObject { public: // Assignment operator overload.MyObject& operator= ( const MyObject & obj ){ // Self-reference check. if( this != &obj ){// Assignment code goes here... } // Return a reference to this object. return( *this ); } }; The 'this' pointer can also be used to pass a pointer (this) or reference (*this) to external functions that accept such arguments. It should also be noted that when referring to an instance member from within a non-static member function, the dereferenced 'this' pointer is implied, as in: this->[member_name] Although this usage is never required, there may be times when it can help make your code more readable, or less ambiguous, especially when a member function must handle one or more external instances of the same class.
