C++构造,析构,友元类,对象,static成员,复制构造函数,运算符重载杂谈

1.

构造函数初始化分配内存

析构函数清空数据,释放内存

#include<stdlib.h>
#include<iostream>

class create
{
int *p;
public:
create(int n)//析构函数初始化分配内存
{
p = new int
;
for (int i = 0; i != n; i++)
{
p[i] = i;
std::cout << p[i] << std::endl;
}
}
~create()//析构函数清空数据,释放内存
{
delete[]p;
}
};
void main()
{

create K(16);
system("pause");

}

#include<iostream>
class circle
{
public:
double R;
public:
circle(double r)//默认空构造函数但如果定义了构造函数,必须使用这个构造函数
{
R = r;
}
public:
void setR(double r)
{
R = r;
}
double area()
{
return R*R*3.1415;
}

};
void maian()
{
int a = 5;
int b(5);
std::cout << a << std::endl;
std::cout << b << std::endl;
system("pause");

}

void mainfasasd()
{
/*circle A;无构造函数或者构造函数默认为空
A.setR(10);
std::cout << A.area() << std::endl;
system("pause");*/
circle B(100); //调用构造函数 也是初始化一个B的对象,必须这样做
std::cout << B.area()<< std::endl;
system("pause");

}

2.
友元类

友元类的所有成员函数都是另一个类的友元函数，都可以访问另一个类中的隐藏信息（包括私有成员和保护成员）。

include<iostream>

class A
{
friend class B;//与B可以共用a的函数和数据
private:
int x;
public:
void printx()
{
std::cout << x << std::endl;
}
};
class B
{
private:
A obj;//创建一个A类的对象
public:
void setx(int a)
{
obj.x = a;
obj.printx();
}
};

int mai111111n()
{

//A A1;
//A1.printx();
B b;
b.setx(100);

system("pause");
return 0;
}

3.友元函数

友元函数是指某些虽然不是类成员却能够访问类的所有成员的函数。类授予它的友元特别的访问权。通常同一个开发者会出于技术和非技术的原因，控制类的友元和成员函数（否则当你想更新你的类时，还要征得其它部分的拥有者的同意）。

#include<iostream>
class OO
{
friend void fun(OO *p, int a);//声明友元函数,
friend void funA(OO&OOA, int a);//声明了友元函数,这个函数可以访问私有
int x;
public:
void printx(int a)
{
x = a;
std::cout << x << std::endl;
}
};
//注意友元函数无this指针
void fun(OO *p, int a)
{
p->x = a;//访问private成员
std::cout << p->x<< std::endl;
}
void funA(OO&OOA, int a)
{
OOA.x = a;//友元函数访问private成员
std::cout << OOA.x<< std::endl;
}
void main()
{
OO OO1;
OO1.printx(100);
fun(&OO1, 1002);
funA(OO1, 1000);
system("pause");
}

对象的创建

include<iostream>

class M
{
int a, b;
public:
M(int x, int y)
{
a = x;
b = y;
}
void seta(int x)
{
a = x;
std::cout << a << std::endl;
}
void setb(int y)const  //强调不可以修改类的内部成员变量
{
//b = y;无法修改  const限定了
std::cout << b << std::endl;
}
};

void ma1111in()
{

M text(2, 4);
text.seta(1);

system("pause");

}

Static成员

#include<iostream>

class simple
{
int x, y;
static const int z =1;
static int u;//在外部初始化
public:
simple(int a, int b, int c)
{
x = a;
y = b;
this->u = c;

}
void printu()
{
std::cout << this->u << std::endl;
}
static void printAB()//静态,不依赖与对象,可以直接运行
{
std::cout << "asdfasf" << std::endl;
}
};
int simple::u(10);//外部初始化
void main()
{
simple A(1, 2, 3);
A.printu();
A.printAB();
system("pause");
//simple::printu();不合法,合法,依赖对象
simple::printAB();//合法,不依赖与对象,可以直接运行
system("pause");
}

复制构造函数

拷贝构造函数，是一种特殊的构造函数，它由编译器调用来完成一些基于同一类的其他对象的构建及初始化。其唯一的形参必须是引用，但并不限制为const，一般普遍的会加上const限制。此函数经常用在函数调用时用户定义类型的值传递及返回。拷贝构造函数要调用基类的拷贝构造函数和成员函数。如果可以的话，它将用常量方式调用，另外，也可以用非常量方式调用。

一般格式 类名(const 类名 &s)//

通过已经存在的对象来初始化自己

Const限定传入的参数在复制构造函数不被修改

#include<stdlib.h>
#include<iostream>
class TTTT
{
int a;
public:
TTTT(int x)
{
a = x;
std::cout << a << std::endl;
}
TTTT(const TTTT &s)//通过已经存在的对象,初始化自己
{  //限定s这个时候不可以修改
a = s.a;
std::cout << a << std::endl;
}
};
void ma11111in()
{

TTTT A1(6);
TTTT A2(A1);
system("pause");
}

浅复制与深复制区别

浅复制（浅克隆）

被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

深复制（深克隆）

被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。

简单的说就是

//浅复制是直接复制指针的地址,共用一段内存
//深复制,就是各自用各值得内存
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
//深拷贝就是除了一般复制,还保存内存复制
//浅拷贝就是一般复制,只指针复制,这样会使2个对象的指针指向同一片内存区域
class name
{
public:
name(char *pn);//成员函数申明
~name();//析构函数声明
name(const name &obj);//复制析构函数声明
void printname()
{
std::cout << pname << std::endl;
}
private:
char *pname;
int size;
};
name::name(char *pn)
{
std::cout << "构造函数创建" << std::endl;
pname = new char[strlen(pn) + 1];
if (pname != 0)
{
strcpy(pname, pn);
size = strlen(pn);
}
}
name ::~name()
{
std::cout << "销毁" << pname << std::endl;
pname[0] = '\0';
delete[]pname;
size = 0;
}
name::name(const name &obj)
{
pname = new char[strlen(obj.pname) + 1];
if (pname != NULL)
{
strcpy(pname, obj.pname);
}
size = obj.size;
//上面是深复制
//浅复制则是 pname=obj.pname指向同一内存地址
}

void main()
{
name obj1("abcd");
obj1.printname();
name obj2(obj1);
obj2.printname();
system("pause");
}

简单运算符重载

#include<iostream>
//x+yi  复数++,--
class fushu
{
private:
int x;
int y;
public:
fushu()
{

}
fushu(int a, int b)//构造函数
{
x = a;
y = b;
}
void printfushu()
{
std::cout << x << "+" << y << "i" << std::endl;
}
fushu operator ++()
{
x++;
y++;
return *this;//返回自己
}
fushu operator --()
{
x--;
y--;
return *this;
}
fushu operator =(fushu b)
{
x = b.x;
y = b.y;
return *this;
}
~fushu()
{

}
fushu operator +(fushu a)//实现复数加法
{
fushu temp(0, 0);
temp.x = x + a.x;
temp.y = y + a.y;
return temp;
}
fushu operator()()
{

}
};

int mai11111n()//main函数无法重载
{
fushu A(3, 5);
A.printfushu();
A++;//重载
A.printfushu();

A--;//重载
A.printfushu();
fushu B;
B = A;//重载
B.printfushu();
A = A + B;
A.printfushu();

system("pause");
return 0;
}

例子2
#include<iostream>

class sanwei
{
private:
int x;
int y;
int z;
public:
sanwei(int a = 0,int b=0,int c=0)
{
x = a;
y = b;
z = c;

}
sanwei operator =(sanwei X)
{
this->x = X.x;
this->y = X.y;
this->z = X.z;
return *this;
}
sanwei operator ++()
{
this->x++;
this->y++;
this->z++;
return *this;
}
sanwei operator+(sanwei X)
{
sanwei temp;
temp.x= this->x + X.x;
temp.y = this->y + X.y;
temp.z = this->z + X.z;
return temp;
}
void show()
{
std::cout << "x=" << x << " " << "y=" << y << " " << "z=" << z << std::endl;
}
void assign(int a, int b, int c)
{
x = a;
y = b;
z = c;
}
};
void maiafadfaAn()
{
sanwei A(1,2,3);
sanwei B;
sanwei C;
A.show();
B.show();
C.show();
B++;
B++;
B.show();
C = A + B;
C.show();
C.assign(1, 2, 3);
C.show();
system("pause");

}
void mainkkk()
{
sanwei A(1,2,3);
sanwei B;
B = A;
A.show();
B.show();
A = A + B;
A.show();
A++;
A.show();

system("pause");

}<span style="color:#57a64a;">
</span>

友元函数实现重载(友元函无this指针)

#include<iostream>

class fushuA
{
friend fushuA operator -(fushuA & U, fushuA &V);//友元函数声明
private:
int x, y;
public:

fushuA(int a=0, int b=0)//构造函数
{
x = a;
y = b;
}
fushuA operator+(fushuA a)//重载运算符
{
fushuA temp(0, 0);
temp.x = x + a.x;
temp.y = y;
return temp;
}
fushuA operator =(fushuA b);//=函数实现声明
void show()
{
std::cout << "x=" << x << "   " << "y=" << y<< std::endl;
}
~fushuA()
{

}
fushuA operator ++()//前置  ++M调用这个
{
this->x++;
this->y++;
return *this;
}
fushuA operator ++(int a)//后置 M++调用这个
{
this->x++; x++;
this->y++;
return *this;
}
fushuA operator[] (fushuA *a)  //[]实现重载
{
std::cout << a->x << a->y << std::endl;
return *this;
}
};
fushuA operator -(fushuA &U, fushuA &V)//友元函数实现运算符重载,因为友元函数木有this指针
{
fushuA C;
C.x = U.x - V.x;
C.y = U.y - V.y;
return C;
}
fushuA fushuA::operator =(fushuA b)//成员函数重载  移到外部
{
x = b.x;
y = b.y;
return *this;
}

void main()
{
/*fushuA A(1, 9);
fushuA B(3, 19);
fushuA D;
fushuA C;
C = B+ A;//自己重载的运算符遵循自己的规则
//	A.show();
C.show();
D = A+ B;
D.show();//与c.show不同,不满足交换律是因为自己的规则
fushuA E = D - C;
E.show();*/
fushuA M(10, 20);
fushuA N;
//N = M++;//指行的是  fushuA operator ++(int a)
//N.show();
N = ++M;//执行的是 fushuA operator ++()
N.show();

fushuA O(15, 25);
O[&O];//[]实现重载

system("pause");

}