c++初步----模板，操作符重载，拷贝构造函数,友元

模板函数：

#include <stdio.h>
#include <iostream>

using namespace std;

template <class T>
T min(T &x,T &y)
{
        return ((x<y)? x:y);
}

int main()
{
        int n1=2,n2=10;
        double d1=1.5,d2=5.6;
        cout<<"int min is"<<min(n1,n2)<<endl;
        cout<<"double min is"<<min(d1,d2)<<endl;
}

模板类：

#include <stdio.h>

template <class T> class Test
{
public:
        T a;
public:
        Test(T temp)
        {
                a=temp;
        }

        T get(void)//在内部
        {
                return a;
        }

        void set(T temp);

        T set2(T temp);
};

template <class T>
void Test<T>::set(T temp)
{
        a=temp;
}

template <class T>
T Test<T>::set2(T temp)
{
        a=temp;
        return a;
}

int main()
{
        Test<int>b(4);
        printf("the a is %d\n",b.get());
        printf("the a is %d\n",b.set2(110));

        Test<double>c(1.2);
        printf("the c is %lf\n",c.get());
        c.set(3.4);
        printf("the c is %lf\n",c.get());

}

操作符重载：

#include <stdio.h>
#include <iostream>

class test
{
public:
        void operator+(int a)
        {
                printf("hello world operate +");
        }
        void operator-(int b);
};

void test::operator-(int b)
{
        printf("operator -  is  %d",b);
}

int main()
{

    test mytest;
        mytest-111;
}

操作符重载2：

#include <iostream>
#include <stdio.h>

using namespace std;

class test
{
public:
    test()
    {
        a=3;
    }
    int operator=(const test& mytest)//两个参数第一个隐含了this指针，返回值可以是任何类型。
    {
        this->a=5;
        return 110;
    }
    int operator++(int a) //后增量
    {
        printf("opetator ++!!!!");
        this->a=100;
        return 1;
    }
public:
    int a;
};

int main()
{
    test ma;
    test mb;
    test t;
    cout<<ma.a<<" "<<mb.a<<endl;
    mb=ma;

    cout<<ma.a<<" "<<mb.a<<endl;
    printf("the return is %d\n",(mb=ma));
    ma++;
    printf("the return test ++ is %d\n",(ma++));
}

友元：

#include <stdio.h>

class test
{
public:
    test()
    {
        a=11;
    }
    friend void show(test &mytest);//一般都要把引用传进来，不然没有意义。
    friend class ttt; //友元声明只能出现再内部。
    void get()
    {
        printf("a is %d\n",a);
    }
private:
    int a;
};

class ttt //可以使用test类的private 成员 //但是对于test的派生类没有权限
{
    public:
    int show(test &b)
    {
        printf("^^this is fridend class a is %d\n",b.a);
    }
    static void gg(test &b)
    {
        printf("^^this is fridend class a is %d\n",b.a);

    }
};

class newttt:public ttt
{
    /*
    int show2(test &b) //重新定义的方法无法在有private 访问权限 //原来的show方法任何有
    {
        printf("show2 is fridend class a is %d\n",b.a);
    }
    */
};


void show(test &mytest) //这里注意定义，不是成员
{
    mytest.a=111;
    printf("this is friend func\n");
}

int main()
{
    test b;
    show(b); //直接使用
    b.get();
    ttt t;
    t.show(b);
    ttt::gg(b);
    newttt nt;
    nt.show(b);
//    nt.show2(b);
}

拷贝构造函数：

#include <stdio.h>
#include <stdlib.h>

class Test
{
public:
        int data;
public:
       Test(int temp)//直接构造函数
       {
                printf("this direct Test\n");
                data=temp;
       }

       Test(){}

       Test(Test &temp)//拷贝构造函数
       {
                printf("this is copy! Test\n");
                data=temp.data;
       }

       void hello(Test temp)//再传递参数到过程中，将调用到拷贝构造函数，再函数完成后就析构了，是临时对象
       {
               printf("hello ooooooooooooooooo\n");
       }

       ~Test()
       {
                printf("~~~~~~~\n");
       }
};

int main()
{
        Test a(111);//这样再main函数结束后，将调到析构函数
        Test b=a;//将调到拷贝构站函数，如果再拷贝构造函数中，没有些data到值，将会是原来内存里的值
        //b.hello(a);
        printf("%d\n",b.data);

        printf("start f\n");
        Test f;
        f=a;//这里不会调到拷贝构造函数
        printf("f------%d\n",f.data);

        Test *c=new Test(111);//用指针指向到对象，如果不delete指针，将不会调到析构函数
        Test *d=c;

        delete(c);
        printf("%d\n",d->data);
}

深度拷贝：

/*
 *在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。

 　　深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝
 * */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

class Test
{
public:
        char *name;
        int data;
        int length;
public:
        Test(){}
        Test(const char *myname,int mydata,int mylength)
        {
                length=mylength;
                data=mydata;
                name=(char *)malloc(10);
                memset(name,0,10);
                memcpy(name,myname,mylength);
        }
        Test(const Test &temp)
        {
                data=temp.data;
                length=temp.length;
                name=new char[length];//重新申请空间
                strcpy(name,temp.name);
        }
};

int main()
{
        Test a("hello",10,3);
        printf("----------------------%d\n",a.data);
        Test b=a;

        printf("%s\n",b.name);
}

模板类：