类(class)

类名 (const 类名 &) ；

class A
{
    private:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){} //构造函数初始化列表
        A(const A &obj) //拷贝构造函数
        {
            // 构造函数的主体
        }
};

int main(int argc, char const *argv[])
{
    A i(1,2);
    A j = i; //调用了拷贝构造
    A k(i); //调用了拷贝构造
    return 0;
}

省略复制

#include 
#include
using namespace std;
class A
{
    private:
        char buf[16];
    public:
        A(const char *str)
        {
            strcpy(buf,str);
            cout << "构造函数" << endl;
        }
        A(const A& a)
        {
            strcpy(this->buf,a.buf);
            cout << "拷贝构造" << endl;
        }
};
int main()
{
    A ob = "nihao";
    return 0;
}

#include 
#include
using namespace std;
class A
{
    private:
        char buf[16];
    public:
        A(const char *str)
        {
            strcpy(buf,str);
            cout << "构造函数" << endl;
        }
        A(const A& a)
        {
            strcpy(this->buf,a.buf);
            cout << "拷贝构造" << endl;
        }
};
A fnn()
{
    return A("nihao");
}
//或
A fuu()
{
    A a("nihao");
    return a;
}
int main()
{
    A ob = fuu();
    return 0;
}

this 指针

class A
{
    private:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){} //构造函数初始化列表
        void fun()
        {
            this->a = 4; //this 就是该对象的地址
            (*this).b = 5; //*this 就相当于对象本身
        }
};

class A
{
    private:
        int a;
        int b;
    public:
        A(int x,int y):a(x),b(y){} //构造函数初始化列表
        void fun(int a,int b)
        {
            //a = a; //erreor ,系统会以为是形参 a 赋值给形参 a，并不会改变成员变量的值
            //b = b; //同上理
            this->a = a;
            this->b = b;
        }
};

void sun ( A * this );

void fun ( int a , int b , A * this );

A a ( 1 , 2 );

a . sun (& a );

a . fun ( 1 , 2 ,& a );

类的静态成员函数

class person
{
public:
    static void func(); //只需要在类内进行声明
};

int main(int argc, char const *argv[])
{
    A::fun();
    return 0;
}

class A
{
    private:
        int a;
        int b;
        static int c;
    public:
        static void fun();
};
int A::c = 0; //静态成员变量初始化

#include 
#include
using namespace std;
class A
{
    private:
        int a;
        int b;
    public:
        static int c;
        static void fun()
        {
            cout << c << endl;
        }
};
int A::c = 0;
int main(int argc, char const *argv[])
{
    A a;
    a.c = 0;
    A::c = 5;
    a.fun();
    return 0;
}

友元函数和友元类(friend)

友元函数

#include 
#include
using namespace std;
class A; //对 A 进行超前声明，不然 sun 参数找不到
int sun(int a,int b,A& c);
class A
{
    private:
        int x;
        int y;
    public:
        A(int a,int b):x(a),y(b){}
        ~A(){}
        friend int sun(int a,int b,A& c);
};
int sun(int a,int b, A& c)
{
    c.x = a;
    c.y = b;
    return c.x+c.y;
}
int main(int argc, char const *argv[])
{
    A a(2,4);
    sun(1,2,a);
    return 0;
}

#include 
#include
using namespace std;
class A; //对 A 进行超前声明，不然 sun 参数找不到
class B
{
    private:
        int i; 
        char j;
    public:
        B(int a,char c)
        {
            i = a;
            j = c;
        }
        ~B(){}
        int fun(A *rm);
};
class A
{
    private:
        int x;
        int y;
    public:
        A(int a,int b):x(a),y(b){}
        ~A(){}
        friend int B::fun(A* rm); //友元
};
int B::fun(A *rm)
{
    i = rm->x + rm->y;
    j = 'a';
    return i;
}
int main(int argc, char const *argv[])
{
    A a(2,4);
    B b(2,'A');
    b.fun(&a);
    return 0;
}

#include 
#include
using namespace std;
class A; //对 A 进行超前声明，不然 sun 参数找不到
class B
{
    private:
        int i; 
        char j;
    public:
        B(int a,char c)
        {
            i = a;
            j = c;
        }
        ~B(){}
        int fun(A &a);
};
class A
{
    private:
        int x;
        int y;
        friend B;
    public:
        A(int a,int b):x(a),y(b){}
        ~A(){}
};
int B::fun(A &a)
{
    i = a.x + a.y;
    return i;
}
int main(int argc, char const *argv[])
{
    A a(2,4);
    B b(2,'A');
    b.fun(a);
    return 0;
}