拷贝构造函数定义格式：类名（const 类名&变量名）

class Student
{public:Student(){m_strName = "Jim";}       
        Student(const Student &stu){} 
//拷贝构造函数在名称上一样，但是在参数设计上却不同
//const +引用    
private:string m_strName;}

如果没有自定义的拷贝构造函数，则系统自动生成一个默认的拷贝构造函数.当采用直接初始化或复制初始化实例化对象时，系统自动调用拷贝构造函数

初始化列表编码：

//Teacher.h文件
#include<iostream>
#include<string>
using namespace std;

class Teacher
{publlic:Teacher(string name = "Tom",int age = 5 ,int m = 100);
         void setName(string name);
         sting getName();
         void setAge(int Age);
         int getAge();
         int getMax();
 private: string m_strName;
          int m_iAge; 
          const int m_iMax; 
}

//Teacher.cpp文件
#include"Teacher.h"

Teacher::Teacher(string name,int age,int m):m_strName(name),m_iAge(age),m_iMax(m)
{cout<<"Teacher(string name,int age,int m)"<<endl;
}
//构造函数名需与类名一致
int Teacher::getMax()
{return m_iMax;}

调用初始化列表编码：

//demo.cpp文件
#include<stdlib.h>
#include<iostreaam>
#include<string>
#include"Teacher.h"

int main(void)
{Teacher t1;//实例化对象
 cout<<t1.getName()<<" "<<t1.getAge()<<" "<<t1.getMax()<<endl;
}

• 初始化列表的存在的必要性：可以对const常量初始化

• 初始化列表的特性：
  初始化列表先于构造函数执行
  初始化列表只能用于构造函数
  初始化列表可以同时初始化多个数据成员

#include"Teacher"
#include<string>

无参构造函数：

Teacher::Teacher()
{ m_strName = "Jerrry";
  m_iAge = 5:
  cout<<Teacher()<<endl;
}

含参构造函数：

Teacher::Teacher(string name, int age)
{m_strName = name;
 m_iAge = age;
 cout<<Teacher(string name,int age)<<endl;
}

调用无参构造函数：

Teacher T1;
cout<<T1.getName()<<" "<<T1.getAge()<<endl;

调用含参构造函数：

Teacher T2("Tom",18);
cout<<T2.getName()<<" "<<T2.getAge()<<endl;

构造函数的规则和特点：
1、构造函数在对象实例化时被自动调用（有且仅有一次）；
2、构造函数与类同名；
3、构造函数没有返回值（连 void 都不用写）；
4、构造函数可以有多个重载形式（遵循重载规则，参数个数、类型、调用顺序不同等）；
5、即使有多个构造函数，实例化对象时仅用到一个构造函数；
6、用户没有定义构造函数时，编译器自动生成一个构造函数。

内存分区
栈区：定义变量。内存由系统进行控制，释放和分配
堆区：关键字new，需要程序员自己管理释放
全局区：全局变量和静态变量
常量区：字符串和常量

类的声明放头文件.h
类的定义放源文件.cpp
#include<string>

#include<iostream> 

 using namespace std;

类内定义的成员函数，编译器会将其优先编译为内联函数。

对于复杂的成员函数，则编译为普通的函数。

类外定义的成员函数的格式： 返回类型 类名::函数名(参数列表)

分文件类外定义：
定义一个类名.h的头文件，用来保存类的定义；
定义一个类名.cpp的文件，用来保存类中成员函数的定义，定义之前要加上#include "类名.h"

1. 类的写法是public写在前面，private写在后面

2. 定义私有成员： m_数据类型+成员名。如：string m_strName

   //以便区分数据成员，知道数据成员是定义在类里面的
   形参：_+成员名。如：void getName(string _name)
   

3. 只读：初始化，只有get函数，不设置set函数。
   

#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()
  {
   return m_iScore;  //设置只读学分
 }

  void initScore()
  {
   m_iScore = 0;  //初始化学生学分
  }
  void study(int _score)
  {
   m_iScore += _score;  //累加学生获得学分
   //m_iScore = m_iScore + _score;
 }

private:

 string m_strName;
 string m_strGender;
 int m_iScore;
};
int main(void)
{
 student stu;
 stu.initScore();
 stu.setName("zhangsan");
 stu.setGender("男");
 stu.study(5);
 stu.study(7);

 cout << stu.getName() << "  " << stu.getGender() << "  " << stu.getScore() << endl;

 system("pause");
 return 0;
}

封装的好处：
1.方便设置条件
2.方便读写权限

#include<iostream>
#include<stdlib.h>
#include<string>
using namespace std ;

int main(void)
{

    string name;
    cout << "please input your name:";
    getline(cin, name);
    if (name.empty())
    {
     cout << "input is null..." << endl;
     system("pause");
     return 0;
    }
    if (name == "imooc")
    {
     cout << "you are Administrator" << endl;
  }
    cout << "hello  " + name << endl;
    cout << "your name length is :" << name.size() << endl;
    cout << "your name first letter is:" << name[0] << endl;

system("pause");

 return 0;
}

 从栈中实例化 ：

Coordinate coor; coor.x=10; coor.y=20;

栈中实例化之后内存自动清除。

从堆中实例化

 Coordinate *p=new Coordinate();  p->x=100; p->y=200;

堆中实例化不一定成功，所以需要判断一下：

if(p==NULL){ return 0;}

  堆中实例化之后需要清除内存，即：

delete p；p=NULL;

类的定义

1、关键字、类名

2、属性（分为公共的和私有的）、数据成员

3、方法、成员函数

初始化列表的存在的必要性，可以对const常量初始化

初始化列表的赋值方法