C++中成员函数的返回类型

Question

Can a non-static member function can have the same type as that of class it is defined inside?

Please explain me as I am new to programming

//defining class complex and adding it
    class complex
    {
    private :
        int real;
        int imaginary;
    public:
        complex(){}
        complex(int x1,int x2);
        void display();
        complex add(complex n1,complex n2)   // can this member function be of complex? type
        { 
            complex temp;
            temp.real=n1.real+n2.imaginary;
            return temp; 
        }
    }

Answer 1

Any member function can have return type that is the class type where it is declared. Consider for example operator = overloading. operator = is a non-static member function of the class.

complex & operator =( const complex & )
{
   // some stuff
   return *this;
}

Answer 2

There is no such restriction. Member function can have any return type that normal function would accept.

Your example will work, but it makes no sense to have this kind of add function as, as it will make no use of the state of an object it is called upon.

For example, you will do:

complex a,b,c,d;

a = b.add(c,d);

a will be a result of operation on c and d . Nothing of b will be involved.

Answer 3

Can a non static member function can have same type as that of class name?

* complex add(complex n1,complex n2) // can this member function be of complex type

Yes is the simple answer

Answer 4

Absolutely, yes. But in the way you have your function add() , it does not matter whether it is a static member function or non-static, as you do not make use of the members of the calling object. You might find it more expressive to code:

complex operator+(complex operand)
{
  return complex(real + operand.real, imaginary + operand.imaginary);
}

Then you will be able to use the '+' operator in a natural and expressive way, for example:

complex a(1,2);
complex b(3,4)
complex c = a + b;

In this case, the operator+ method will be called for a , and within the body of the operator, the member variables real and imaginary will implicitly be a 's members, and b will be represented by operand .