对象结构

1. 内存中按照用途分为的五个区：
   
   

2. 

3. 
   

   
   

1. 类内定义与内联函数的关系
   类内定义的成员函数，编译器优先将其以内联函数的方式编译。但不会显示 inline。
   

2. 类外定义
   定义：成员函数定义在类的外部。
   分为两种：同文件类外定义和分文件类外定义。
   同文件类外定义：
   
               类名+“：：”+函数名的形式，定义。
   分文件类外定义：
   在头文件（.h）在生命，在cpp文件中定义。
   
   

    类内定义和内联函数

1.内联函数关键字 inline，其与普通函数的区别如下：

#include <iostream>

#include <string>

using namespace std;

/**

  * 定义类：Student

  * 数据成员：m_strName

  * 数据成员的封装函数：setName()、getName()

  */

class Student

{

public:

    // 定义数据成员封装函数setName()

    void setName(string _name)

    {

        m_strName=_name;

    }

    // 定义数据成员封装函数getName()

    string getName()

    {

        return m_strName;

    }

//定义Student类私有数据成员m_strName

private:

    string m_strName;

};

int main()

{

    // 使用new关键字，实例化对象

Student *str = new Student();  //从堆中实例化对象，new 后跟的为 类名称

    // 设置对象的数据成员

str->setName("慕课网");

    // 使用cout打印对象str的数据成员

    cout<<str->getName()<<endl;

    // 将对象str的内存释放，并将其置空

delete str;

str=NULL;

return 0;

}

#include<iostream>
#include<stdlib.h>
#include<string>
using namespace std;
class Student
{
public:
    void setName(string _name)
    {
    m_strName = _name;
    }
    string getName()
    {
    return m_strName;
    }
    void setGender(string _gender)
    {
    m_strGender = _gender;
    }
    string getGender()
    {
    return m_strGender;
    }
    int getScore()    //score为只读属性
    {
    return m_iScore;
    }
    void initScore()// 初始化
    {
    m_iScore=0;
    }
    void study(int _score)
    {
    m_iScore += _score;
    }
private:
    string m_strName;
    string m_strGender;
    int m_iScore;
};
int main(void)
{
    Student stu;
    stu.initScore();  //初始化0，使得分值可控
    stu.setName("wenqi");
    stu.setGender("男");
    stu.study(10);
    stu.study(8);
    cout << stu.getName() << " " << stu.getGender() << " " << stu.getScore() << endl;
    //细节：引用数据对象的函数记得加括号
    system("pause");
    return 0;
}

1. 命名规则开始规范：
   （1）形参采用 _ 加 名字的形式；
   （2）定义数据成员命名规则：m_数据类型+名字 
             eg1:  string m_strName;
             eg2:int m_iAge
   

2. 一般变量既写其set函数，又写其get函数。设置只读时，只写其get函数。

                                             数据的封装
1.面向对象的基本思想：谁做什么。
   对象的所有行为均通过调用自己的函数完成。

2.数据封装的优点
  通过数据封装，确定某些参数的只读属性。

1. 字符串类型 string。
   （1）初始化对象的方式：
   
   （2）string的常用操作：
   
   （3）几个例子表示初始化：
   
   

2. 注意事项：
   （1）使用string之前加头文件：#include<string>
     (2)  使用string 可简化重复繁琐的字符串操作。
   （3）判断输入是否为空可用  getline（）函数；
           string name;
           getline(cin,name);    //cin表输入流，name为定义的字符串
           if(name.empty())
           // 输入的name为空
   

1. 对象实例化
   （1）从栈实例化
   
   （2）从堆实例化
   
   

2. 补充知识：栈和堆的区别。
   所以堆与栈的区别很明显： 
    1.栈内存存储的是局部变量而堆内存存储的是实体；
   2.栈内存的更新速度要快于堆内存，因为局部变量的生命周期很短； 3.栈内存存放的变量生命周期一旦结束就会被释放，而堆内存存放的实体会被垃圾回收机制不定时的回收。

3. 对象成员的访问
   从栈中实例化使用符号为“.”;
   从栈中实例化使用符号为“->”;

4. 注意细节：
   从堆中，最后要判断是否为空指针，释放内存等；
   定义类时记得加访问限定符；
   实例化对象：类的名称加变量名方式定义对象。
   语句符合标准(定义类时最后的 ； )。

1. 通过例子引出 类和对象的定义。
   对象是具体的事物，类是从对象中抽取出来的。

     关键字-属性-方法

2.访问限定符：

                  public：公共的；protected:受保护的；  private：私有的。

类{命名空间；成员函数；数据成员；}
数据成员{普通数据成员；string；const成员；静态数据成员；对象成员；}
成员函数{属性封装函数；一般功能函数；特殊函数{构造函数{拷贝构造函数；默认构造函数}；析构函数}}
成员函数{参数默认值；函数重载；引用；const；}
对象实例化{堆中实例化；栈中实例化；}

//Teacher.h文件
class Teacher
{public: Teacher(string name = "Jim",int age = 18);//构造函数
         Teacher(const Teacher &tea); //拷贝构造函数
         ~Teacher(); //析构函数
 }

//Teacher.cpp文件
Teacher::Teacher(string name, int age):m_strName(name),m_iAge(age)
{cout<<"Teacher(string name,int age)"<<endl;}
Teaher::Teacher(const Teacher &tea)
{cout<<"Teacher(const Teacher &tea)"<<endl;}
Teacher::~Teacher()
{cout<<"~Teacher()"<<endl;}

//demo.cpp文件
int main(void)
{Teacher t1;  //用栈实例化对象
 Teacher *p = new Teacher();
 delete p; //用堆实例化对象
}

对象生命历程：

申请内存—初始化列表——构造函数—

参与运算——析构函数——释放内存

析构函数：

class Student
{public: Student() 
         {m_pName = new char[20]}
         ~Student()
         {delete []m_pName;}
 private:char *m_pName;

拷贝函数的初始化 

 Teacher(const Teacher &tea) :                                                              
  m_strName(tea.m_strName),                               
  m_age(tea.m_age) {...}                            
  Teacher(const Teacher & tea){}

在作为传递参数的时候 拷贝函数也会被调用