封装

1.对象就是一个东西，类就是有选择的展示对象。

类有两个应用方式。一个是

new申请内存。有可能申请失败，用->

类*P=new 类()

if（P==NULL）

{

}

delete p。如果定义的是个数组呢，那么就delete p[];    

P=NULL；

还有个用栈

从栈中实例化

TV tv;

TV tv[30];系统可以自动回收内存

从堆中实例化对象

TV *p=new TV();

TV *q=new TV[20];

delete p;

delete []q;手动释放内存

直接用点就行。

还有别人不关心private是什么，你自己看。只关心public。

2.string字符串数组操作函数char全是函数，太复杂

初始化

string s1;   S1空串

string s2("abc) 用字符串字面值初始化s2

string s3(s2)  将s3初始化为s2的一个副本

string s4(n,'c')  将s4初始化为字符'C'的n个副本

string类型

string s6="hello"+"world"这是非法的

3.面向对象

思想：以对象为中心，谁做什么表达程序的逻辑

所有程序转化为函数的调用。

封装

4.内联函数

inline直接省去这个的2和4

内联函数要简单比较好。加个inline就行。

类内定义--定义一个类的时候，将函数体定义在内部就是类内定义。

编译器将类内定义的函数优先当成类内定义。

class ss

{

   public:

       inline  void 函数

}

类外定义

同文件类外定义

class 类

{

  public:

       void run();

}

void 类::run();

分文件类外定义

char.h                    car.cpp

                               #include <car.h>

class  类                void car::run()

{                                {}

   public:

      void run();

}

对象结构

内存分区

栈区：定义变量时候用的，定义变量或者指针。int x=0,int *p=NULL系统分配

堆区：只要用new int *p=new int[20].之后要delete

全局区：存储全局变量

代码区：代码放在那里

常量区：

对象初始化。

构造函数在对象实例化时被自动调用。

构造函数与类同名

构造函数没有返回值

构造函数可以有多个重载形式

实例化对象时仅用到一个构造函数

当用户没有定义构造函数时，编译器自动生成一个构造函数

无参构造函数

class stu

{

   public:

        student()

}

有参构造函数

class stu

{

   public:

      student(string name)

}

重载构造函数（重载？）

class stu

{

  public:

     student()

}

构造函数用来初始化，名字和类的名字一样的。

Teacher::teacher()

{

  m_name="jim";

  m_age=5;

}

Teacher::teacher(string name,int age)

{

  m_name=name;

  m_age=age;

}

默认构造函数

student stu1();堆中实例化

student *p NULL;

p=new student();栈中实例化

初始化列表

student()::m_strname("jim"),m_age("10");

初始化列表先于构造函数

初始化列表只能用于构造函数

初始化列表可以同时初始化多个数值。

析构函数

像系统归还内存

析构函数没有返回值，没有参数不能重载

申请内存-》初始化列表-》构造函数-》参与运算-》析构函数-》释放内存