"C + + Institute" (8) global functions and class member functions conversions/friend/operator overloading

Source: Internet
Author: User
Tags function prototype

1. Global functions and class member function conversions

Mutual transformation of global functions and member functions: you only need to modify a pointer to this class .

#include <iostream>using namespace Std;class test{public:test (int a, int b) {this->a = A;this->b = b;} member function test &GADD2 (test &t2) {this->a = this->a + t2.a;this->b = this->b + T2.b;return *this;} Public:int A;int b;};/ /global function Test &GADD1 (test &t1, test &t2) {test t3 (0, 0); t3.a = t1.a + t2.a;t3.b = t1.b + t2.b;return t3;} Converting from a member function to a global function requires only a pointer to the This class (a pointer to the class)//from the global function to the member function of the class is, need to subtract one to do the left operand argument void main () {Test T1 (1, 2), T2 (3, 4);//test t3 = GADD1 (t1, t2); T1. GADD2 (T2); System ("Pause");}
2. Friend $2.1 friend function

#include "iostream" using namespace Std;class test2{public:    //friend function is characterized by a friend class pointer or a reference    friend int Opmem (Test2 *p, int a); Friend function    Test2 (int a, int b)    {        this->a = A;        This->b = b;    }    int Geta ()    {        return this->a;    } Protected:private:    int A;    int b;}; int Opmem (Test2 *p, int a) {    p->a = A;    return 0;} void Main () {    Test2 T1 (1, 2);    T1.geta ();//without friend, if you get the private data of the object T1, you need to use the Get method.    Opmem (&T1, ten);    System ("Pause");}

2.2 Friend Class

#include <iostream>using namespace Std;class a{friend class b;//b is a friend public:void  Display () {cout << x << Endl; };p rivate:int  x;};/ /design pattern in the combined scene. Representation is set B100, which essentially modifies the data of a. Class  b{public:void Set (int i) {aobject.x = i;} void Display ()  {aobject.display ();} Private:a  aobject;}; void Main () {B  bobject; Bobject.set (100); Bobject.display (); System ("Pause");}


3.operator OverloadingC + + has many built-inData type, including int,char,double, and so on, each type has manyOperator, such as add, subtract, multiply, divide, etc. When a user defines an object of a class, these operations cannot be performed between two objects, such as an object a+b of the Hyong class, such that a statement without overloading +Operatorwill go wrong. But C + + allows users to put theseOperatoradded to your own class to facilitate operations between class objects likeBuilt-in typesis as convenient as the object a+b, so it is clear that it is easier to understand, of course, you can also define a function that adds to an object in a class, such as A.add (b) Call function Add () to add two objects A and B, but this statement is no easier to understand than a+b.
3.1 operator overloading via a friend function,

#include <iostream>using namespace Std;class fushu{private:    int A;    int b;    Using friend function to implement + operation    friend Fushu operator+ (Fushu &c1, Fushu &c2);p ublic:    fushu (int a=0, int b=0)    {        This->a = A;        This->b = b;    }    void print ()    {        cout << a << "+" << b << "i" << Endl;    }}; Fushu operator+ (Fushu &c1, Fushu &c2) {    Fushu tmp;    Tmp.a = c1.a + c2.a;    tmp.b = c1.b + c2.b;    return TMP;} void Main () {    Fushu C1 (1, 2), C2 (3, 4);    Fushu C3 = C1+c2;    C3.print ();    System ("Pause");}

#include <iostream>using namespace Std;class fushu{private:    int A;    int b;    Using the friend function to implement the Pre + + operation    friend Fushu &operator++ (Fushu &c2);p ublic:    fushu (int a=0, int b=0)    {        this- >a = A;        This->b = b;    }    void print ()    {        cout << a << "+" << b << "i" << Endl;    }}; Fushu &operator++ (Fushu &c2) {    c2.a++;    c2.b++;    return C2;} void Main () {    Fushu C1 (1, 2), C2 (3, 4);    ++C2;        C2.print ();        System ("Pause");}

3.2 operator overloading through member functions of a class

#include <iostream>using namespace Std;class fushu{private:int A;    int b; Through the Friend function implementation + operation friend Fushu operator+ (Fushu &c1, Fushu &c2);p ublic://through the class member function implementation-Operation Fushu operator-(Fushu        &AMP;C2) {Fushu tmp;        Tmp.a = this->a-c2.a;    TMP.B = b-c2.b;//Here can omit the return TMP;        }public:fushu (int a=0, int b=0) {this->a = A;    This->b = b;    } void Print () {cout << a << "+" << b << "i" << Endl; }};    Fushu operator+ (Fushu &c1, Fushu &c2) {Fushu tmp;    Tmp.a = c1.a + c2.a;    tmp.b = c1.b + c2.b; return TMP;}    void Main () {Fushu C1 (1, 2), C2 (3, 4);    Fushu C3 = C1+c2;//operator+ (C1,C2); C3.print ();//target through the member functions of the class, complete the operator overload//1 to admit that the operator overload is a function, to write function prototype//2 write function call language c1.operator-(C2)//3 perfect function prototype Fushu C4 = c1-c2;/    /operator-(C1,C2)-->c1.operator-(C2)-->fushu operator-(Fushu &c2);    C4.print (); System ("Pause");}

#include <iostream>using namespace Std;class fushu{private:    int A;    int b;    Using the friend function to implement the Pre + + operation    friend Fushu &operator++ (Fushu &c2);p ublic:    fushu (int a=0, int b=0)    {        this- >a = A;        This->b = b;    }    void print ()    {        cout << a << "+" << b << "i" << Endl;    } PUBLIC://is implemented by the member function of the class-operation    fushu& operator--()    {        this->a--;        this->b--;        return *this;}    ; Fushu &operator++ (Fushu &c2) {    c2.a++;    c2.b++;    return C2;} void Main () {    Fushu C1 (1, 2), C2 (3, 4);    The former + + operation ++C2 is realized by the friend function    .        C2.print ();    Through the member functions of the class before-operation    --c2;        C2.print ();    System ("Pause");}

Comprehensive:

 #include <iostream>using namespace Std;class fushu{private:int a;int b;//using friend function to implement pre + + operation friend Fushu &operator++ (Fushu &C2);//through the friend function to achieve after + + operation friend Fushu operator++ (Fushu &c2, int);//with default parameter placeholder, front + + differentiate Public:fushu (int a=0, int b=0) { This->a = A;this->b = b;} void print () {cout << a << "+" << b << "i" << Endl;} public://through the member functions of the class before-operation fushu& operator--() {This->a--;this->b--;return *this;} Before the member function of the class is implemented--operation fushu& operator--(int)//with default parameter placeholder, followed--differentiate {Fushu tmp;tmp = *this;this->a--;this->b--;return tmp;}}; Fushu &operator++ (Fushu &c2) {C2.a++;c2.b++;return c2;} Fushu operator++ (Fushu &c2, int) {Fushu tmp;tmp = C2;c2.a++;c2.b++;return tmp;} void Main () {Fushu C1 (1, 2), C2 (3, 4),//the first + + operation through the friend function ++c2;c2.print ();//through the member functions of the class before-operation--c2;c2.print ();//After the friend function to achieve the Post + + Operation C2++;c2.print ();//through the member function of the class-operation C2--;c2.print (); System ("Pause");} 


3.3 The normal notation of operator overloading can get the private property of the friend class through the friend function, which is equivalent to acquiring a backdoor of the program.
#include <iostream>using namespace Std;class fushu{private:int a;int b;friend ostream& operator<< ( Ostream &cout, Fushu &c);p ublic:fushu (int a=0, int b=0) {this->a = A;this->b = b;} void print () {cout << a << "+" << b << "i" << Endl;} public://the first + + operation through the member functions of the Class Fushu &operator++ () {This->a++;this->b++;return *this;} Pre-operation fushu& operator--() {This->a--;this->b--;return *this by the member function of the Class) After the implementation of the member function of the class-operation Fushu operator--(int)//with the default parameter placeholder, followed--distinguish {Fushu tmp;tmp = *this;this->a--;this->b--;return tmp;} The Post + + operation is implemented by the member function of the class Fushu operator++ (int)//with the default parameter placeholder, followed--differentiates {Fushu tmp;tmp = *this;this->a++;this->b++;return Tmp;}};o stream& operator<< (ostream &co, Fushu &c) {cout << "I am plural:" << endl;cout << c.a <&lt ; "+" << c.b << "i" << Endl;return Co;} void Main () {Fushu C1 (1, 2), C2 (3, 4); ++c2;c2.print ();--c2;c2.print (); C2++;c2.print (); C2--;c2.print (); cout << 1 << Endl; cout << "Hello" << endl;//function returns worth Lvalue, need to return a reference to an object, implement chained programming cout << C2 << "continuous" << endl;//no method To add function operator<&lt to the cout class, only through the global function. cout.operator<< (C1);//void operator<< (Ostream &out, Complex &c1) system ("pause");

3.4 Application of operator overloading in a project: basic array Frame Array.h
Array.h#ifndef _array_h_#define _array_h_class array{private:int mlength;//array length int* mspace;//memory Space Public:array ( int length); Array (const array& obj);//copy constructor int length ();//get array length void setData (int index, int value); int getData (int index); Array ();}; #endif
Array.cpp
Array.cpp#include "Array.h" array::array (int length) {if (length < 0) {length = 0;} Mlength = Length;mspace = new Int[mlength];} Array::array (const array& obj) {mlength = Obj.mlength;mspace = new Int[mlength];for (int i = 0; i<mlength; i++) {MSPA Ce[i] = Obj.mspace[i];}} int Array::length () {return mlength;} void Array::setdata (int index, int value) {Mspace[index] = value;} int array::getdata (int index) {return mspace[index];} Array::~array () {mlength = -1;delete[] mspace;}
ArrayTest.cpp
Arraytest.cpp#include "Array.h" #include <iostream>using namespace Std;int main () {Array a1 (n); for (int i = 0; i&l T;a1.length (); i++) {A1.setdata (I, i);  A[i] = 1;} for (int i = 0; I<a1.length (); i++) {printf ("Array%d:%d\n", I, A1.getdata (i));//printf ("Array%d:%d\n", I, A1[i]);} Array a2 = a1;for (int i = 0; I<a2.length (); i++) {printf ("Array%d:%d\n", I, A2.getdata (i));} System ("pause"); return 0;}

code after overloading the [] = = = = = Operator:
Array.h#ifndef _array_h_#define _array_h_#include <string.h>class array{private:int mlength;//The length of the array int* mspace;//memory space Public:array (int length); Array (const array& obj);//copy constructor int length ();//get array length void setData (int index, int value); int getData (int index); Array ();p Ublic:int & operator[] (int i), void operator= (array &a2), bool operator== (array &a1); bool operator! = (Array &a1);}; #endif

Array.cpp#include "Array.h" array::array (int length) {if (length < 0) {length = 0;} Mlength = Length;mspace = new Int[mlength];} Array::array (const array& obj) {mlength = Obj.mlength;mspace = new Int[mlength];for (int i = 0; i<mlength; i++) {MSPA Ce[i] = Obj.mspace[i];}} int Array::length () {return mlength;} void Array::setdata (int index, int value) {Mspace[index] = value;} int array::getdata (int index) {return mspace[index];} Array::~array () {mlength = -1;delete[] mspace;} int& array::operator[] (int i) {return this->mspace[i];} void Array::operator = (Array &a2) {if (this->mspace! = NULL) {delete[] mspace;}    Mlength = A2.mlength;mspace = new Int[mlength]; memcpy (Mspace, A2.mspace, mlength);} BOOL array::operator== (Array &a1) {//First compare length if (mlength! = A1.mlength) {return false;} Compare contents for (int i = 0; i < a1.mlength; i++) {if (A1[i]! = Mspace[i]) {return false;}} return true;} Use equality to judge unequal bool Array::operator!= (Array &a1) {return! A1 = = *this);}

Arraytest.cpp#include "Array.h" #include <iostream>using namespace Std;int main () {Array a1 (n); for (int i = 0; i&l T;a1.length (); i++) {//a1.setdata (I, i);  A1[i] = i;} for (int i = 0; I<a1.length (); i++) {//printf ("array%d:%d\n", I, A1.getdata (i));p rintf ("Array%d:%d\n", I, A1[i]);}  Array a2 = a1;for (int i = 0; I<a2.length (); i++) {//printf ("array%d:%d\n", I, A2.getdata (i));p rintf ("Array%d:%d\n", I, A1[i]);} Array A3; a3 = A2; Execute = Action if (a2 = = A1) {printf ("equal");} else{printf ("unequal");} System ("pause"); return 0;}







"C + + Institute" (8) global functions and class member functions conversions/friend/operator overloading

Contact Us

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.