1、对象和类概念
对象：实体,真实存在的个体。
编译器为之分配空间的变量。
特征属性，行为。
类： 具有共性的实体的抽象。
自定义的数据类型
struct stu
{
int age;
};
struct stu xiaoming;
xiaoming就是对象，struct stu就是类。
2、C++对于结构的增强
struct stu
{
char *name; //数据
int age;
void fun()
{
printf("age\n",age);
}
};
a.结构名可以直接做类型名。
C:struct stu xiaoming;
C++:stu xiaoming;
b.结构中可以定义函数。
c.结构中对于数据和函数有权限的划分。（封装性）
public(公共的)：类内和类外均可以访问
private(私有的):只能在类内访问，类外无法访问。
protected(受保护的):只要不涉及到继承，和private相同。
补充：
1.struct关键字定义的类型中如果成员前没有权限符修饰，默认为public
2.权限符生效范围是上个权限符到下个权限符中间的部分。
3.权限符可以出现任意次，但不建议这样使用。
注意：
1、C++的结构除了上述增强外，其余基本和C中没有差别，
如：成员访问方法，对齐原则等均一样。
2、类的成员函数应当在外部定义，内部给出声明即可。外部定义时要指定函数的作用域。
C++使用class关键字用于定义类，和struct关键字的用法相同。只不过class关键字默认的类型为private
3、对象的引用
a.同一类的对象可以相互赋值。
当类中有指针且有动态内存分配时，不要随便赋值，有可能会出现问题。
4.构造函数
构造函数主要用于在定义对象时，完成对象的初始化.
每一个类都应该有一个构造函数，如果用户没有定义构造函数，
编译器会自动生成构造函数(参数和函数体为空的构造函数)，如果用户自定义了构造函数，那么编译器不再提供默认的构造函数。
特性：
1.构造函数的名称必须要与当前类的名称相同。
2.构造函数仅在定义对象时由系统调用，其他时间无法调用。
3.构造函数可以有参数，也可以没有参数，但是不允许有返回值。
4.构造函数只能定义为公有成员，不能定义为其他。
调用条件：
1.定义对象时。
2.为对象分配动态内存时。
3.定义无名对象（稍作了解）
注意：
构造函数可以进行重载，以便用于不同形式的对象的定义。
构造函数还可以使用默认的缺省参数。如果构造函数既有重载，又有缺省参数时，注意不要产生二义性。
5.析构函数
析构函数是一种特殊的成员函数，完成与构造函数相反的工作，对象退出生命周期时，完成清理的工作。如：释放内存等。
特性：
1.析构函数的名称与类的名称相同。为了区分，析构函数名字前面有~
构造：stu(){}
析构：~stu(){}
2.析构函数无参、无返回值。
3.析构函数不可重载。每一个类有且只有一个析构函数，但是可以有多个构造函数。
4.在对象退出生命周期时，编译器会自动调用析构函数。但是，可以人为调用析构函数，不过没意义。
5.一般情况下，使用系统默认的析构函数就可以。当类中有动态内存分配时，需要增加自定义的析构函数，否则有可能会导致内存泄露。
调用条件：
1.对象退出生命周期时。
2.释放动态分配的对象空间。
6.析构顺序
同一作用域下，先构造的后析构。
7.拷贝构造函数
在定义对象时，使用已知对象初始化新的对象。
特性：
1、拷贝构造函数也是构造函数，名称为类的名字，无返回值。
2、如果没有自定义的拷贝构造函数，系统会提供默认的拷贝构造函数
stu(const 当前类的对象的引用)
{
}
当类中有指针且进行动态内存分配时，要使用自定义的拷贝构造函数。
3、可以自定拷贝构造函数，如果自定义后，默认的拷贝构造函数失效。
补充：
浅拷贝：只复制数据，没复制内存空间。
深拷贝：既拷贝数据，也要复制内存空间。
调用条件：
1、使用已知对象初始化新对象。
stu s2 = s1;
2、如果函数参数是某类的对象
void fun(stu s1){}
fun(s2);
3、如果函数返回值为某类的对象时。
stu fun(){}
stu s1 = fun();
如果使用无名对象初始化新的对象，不会调用拷贝构造函数。
8、const修饰的成员函数
对于一般的成员函数来说，可以访问和修改任意数据成员的值。
如果不希望某个成员函数修改成员的值可以使用const修饰该函数。
格式：
返回值类型 函数名(参数列表)const
void stu::getnum()const
{
}
如果希望const修饰的成员函数还可以改变某个成员值，可以在该成员前使用mutable修饰。
例子：
C++拷贝构造函数(深拷贝，浅拷贝)
对于普通类型的对象来说，它们之间的复制是很简单的，例如：
int a=88;
int b=a;
而类对象与普通对象不同，类对象内部结构一般较为复杂，存在各种成员变量。下面看一个类对象拷贝的简单例子。
#include <iostream>using namespace std;
class CExample {
private: int a;public: CExample(int b)
{ a=b;} void Show () { cout<<a<<endl;
}
};int main(){ CExample A(100); CExample B=A; B.Show (); return 0;}
运行程序，屏幕输出100。从以上代码的运行结果可以看出，系统为对象B分配了内存并完成了与对象A的复制过程。就类对象而言，相同类型的类对象是通过拷贝构造函数来完成整个复制过程的。下面举例说明拷贝构造函数的工作过程。
#include <iostream>using namespace std;class CExample {private: int a;public: CExample(int b) { a=b;} CExample(const CExample& C) { a=C.a; } void Show () { cout<<a<<endl; }};int main(){ CExample A(100); CExample B=A; B.Show (); return 0;}
CExample(const CExample& C)就是我们自定义的拷贝构造函数。可见，拷贝构造函数是一种特殊的构造函数，函数的名称必须和类名称一致，它的唯一的一个参数是本类型的一个引用变量，该参数是const类型，不可变的。例如：类X的拷贝构造函数的形式为X(X& x)。
当用一个已初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用。也就是说，当类的对象需要拷贝时，拷贝构造函数将会被调用。以下情况都会调用拷贝构造函数：
一个对象以值传递的方式传入函数体
一个对象以值传递的方式从函数返回
一个对象需要通过另外一个对象进行初始化。
如果在类中没有显式地声明一个拷贝构造函数，那么，编译器将会自动生成一个默认的拷贝构造函数，该构造函数完成对象之间的位拷贝。位拷贝又称浅拷贝，后面将进行说明。
自定义拷贝构造函数是一种良好的编程风格，它可以阻止编译器形成默认的拷贝构造函数，提高源码效率。
浅拷贝和深拷贝
在某些状况下，类内成员变量需要动态开辟堆内存，如果实行位拷贝，也就是把对象里的值完全复制给另一个对象，如A=B。这时，如果B中有一个成员变量指针已经申请了内存，那A中的那个成员变量也指向同一块内存。这就出现了问题：当B把内存释放了（如：析构），这时A内的指针就是野指针了，出现运行错误。
深拷贝和浅拷贝可以简单理解为：如果一个类拥有资源，当这个类的对象发生复制过程的时候，资源重新分配，这个过程就是深拷贝，反之，没有重新分配资源，就是浅拷贝。下面举个深拷贝的例子。
#include <iostream>
using namespace std;
class CA
{
public:
CA(int b,char* cstr)
{
a=b;
str=new char[b];
strcpy(str,cstr);
}
CA(const CA& C)
{
a=C.a;
str=new char[a]; //深拷贝
if(str!=0)
strcpy(str,C.str);
}
void Show()
{
cout<<str<<endl;
}
~CA()
{
delete str;
}
private:
int a;
char *str;
};
int main()
{
CA A(10,"Hello!");
CA B=A;
B.Show();
return 0;
}
深拷贝和浅拷贝的定义可以简单理解成：如果一个类拥有资源(堆，或者是其它系统资源)，当这个类的对象发生复制过程的时候，这个过程就可以叫做深拷贝，反之对象存在资源，但复制过程并未复制资源的情况视为浅拷贝。
浅拷贝资源后在释放资源的时候会产生资源归属不清的情况导致程序运行出错。
Test(Test &c_t)是自定义的拷贝构造函数，拷贝构造函数的名称必须与类名称一致，函数的形式参数是本类型的一个引用变量,且必须是引用。
当用一个已经初始化过了的自定义类类型对象去初始化另一个新构造的对象的时候，拷贝构造函数就会被自动调用，如果你没有自定义拷贝构造函数的时候，系统将会提供给一个默认的拷贝构造函数来完成这个过程，上面代码的复制核心语句就是通过Test(Test &c_t)拷贝构造函数内的p1=c_t.p1;语句完成的。