Ｃ++学习总结11--类和对象，类的定义和实例化

小记：静默如初，安之若素

1. 类和对象

1. 什么是对象
万物皆对象，任何一种事物都可以看做是对象。
2. 如何描述对象
通过对象的属性（名词，数量词，形容词）和行为（动词）来描述对象。

     eg：描述冰箱对象
     属性：品牌，容量，颜色，功耗
     行为：装东西，冷冻，冷藏

3. 面向对象的程序设计
对自然世界中对象的描述引入到编程实践的方法，这种方法称为“数据抽象”，即在描述对象的时候把细节的东西剥离出去，而只考虑一般性的，有规律性的，统一的东西。
4. 什么是类？
类是将多个对象的共性提取出来定义的新的数据类型，是对对象属性和行为的抽象描述。

2.类的定义和实例化

1. 类的一般形式

class/struct 类名：继承方式 基类，...{
访问控制属性：
	类名（形参表）：初始化表{} //构造函数
	～类名（void）{} //析构函数
	返回类型 函数名（形参表）{}//成员函数
	数据类型 变量名;//成员变量
};

2. 访问控制属性
2.1 public:公有成员，类的内部和外部都可以访问的成员
2.2 protected:保护成员
2.3 private:私有成员，只有在类的内部才可以访问的成员
注：使用class定义的类默认的访问控制属性是private， 而使用struct定义的类默认的访问
控制属性是public。

eg:
 1 #include <iostream>
  2 using namespace std;
  3 
  4 //原来叫定义结构体，现在叫定义类
  5 //struct Student//struct 中的属性默认是公有的，class中的属性默认是私有的
  6 class Student
  7 {
  8 public:
  9   //行为：用成员函数描述
 10   void eat(const string &food)//string其实是一个类，对于类类型的参数都需要加引用，减少程序开销
 11   { 
 12     cout<<"I eat : "<<food<<endl;
 13   }
 14   void sleep(int hour)
 15   { 
 16     cout<<"I sleep "<<hour<<" hours"<<endl;
 17   }
 18   void learn(const string &course)
 19   { 
 20     cout<<"I am learning : "<<course<<endl;
 21   }
 22   void who(void)
 23   { 
 24     cout << "my name : "<< m_name << ", age : "<< m_age <<
 25         ", number : "<< m_num <<endl;
 26   }
 27 
 28 private:
 29   //属性：用成员变量描述
 30   string m_name;//私有
 31 public:
 32   //私有成员在类的外部不能直接访问，
 33   //但是可以提供公有的函数间接访问，在函数中可以
 34   //对非法数据加以限定，控制逻辑合理性
 35   void setName(const string &name)
 36   { 
 37     if(name == "two")
 38     { 
 39       cout<<"error"<<endl;
 40     }
 41     else
 42     { 
 43       m_name = name;
 44     }
 45   }
 46 public: 
 47   int m_age;
 48   int m_num;
 49 };
 50 
 51 int main(int argc, char * argv[])
 52 {
 53   //原来叫定义结构体类型变量
 54   //现在叫做创建对象，或实例化对象
 55   Student s;
 56   //s.m_name = "zhangfei";
 57   s.setName("zhangyide");
 58   s.setName("two");
 59   s.m_age = 18;
 60   s.m_num = 123456;
 61   s.who();
 62   s.eat("apple");
 63   s.sleep(8);
 64   s.learn("C++");
 65 
 66   return 0;
 67 }
运行结果：
error
my name : zhangyide, age : 18, number : 123456
I eat : apple
I sleep 8 hours
I am learning : C++

3. 构造函数（Constructor）
3.1 构造函数的函数名和类名相同，没有返回值；
3.2 构造函数在创建对象时自动被调用，不能像普通成员函数一样直接去调用。

构造函数的形式：
class 类名{
	类名（构造形参表）{
		//主要负责对象的初始化，即初始化成员变量
	}
}；

eg:
  1 #include <iostream>
  2 using namespace std;
  3 
  4 class Student
  5 {
  6 public:
  7   Student(const string& name, int age, int id)
  8   {
  9     cout <<"构造函数"<<endl;
 10     m_name = name;
 11     m_age = age;
 12     m_id = id;
 13   } 
 14 
 15   void who(void)
 16   {
 17     cout << "My name : "<<m_name<<" , age : "<<m_age<<", num : "<<m_id<<endl;
 18   } 
 19   
 20 private:
 21   string m_name;
 22   int m_age;
 23   int m_id;
 24 };
 25 
 26 int main()
 27 {
 28   //创建对象，构造函数将自动被调用
 29   //(...)：指明构造函数所需要的实参
 30   Student s("rxl", 22, 12346);
 31   s.who();
 32   //构造函数不能显示的调用
 33   //s.Student("xl", 21, 1234);//error
 34   return 0;
 35 }
~      

**练习：**实现一个电子时钟类，要求适用构造函数初始化当前的时间，以秒单位运行。

//查看time函数的源码：man 2 time
  1 #include <iostream>
  2 #include <cstdio>
  3 #include <ctime>
  4 #include <unistd.h>
  5 
  6 using namespace std;
  7 
  8 class Clock{
  9 public:
 10   Clock(time_t t)
 11   {
 12     tm *local = localtime(&t);
 13     m_hour = local->tm_hour;
 14     m_min  = local->tm_min;
 15     m_sec = local->tm_sec;
 16   }
 17 
 18   void run(void)
 19   { 
 20     while(1)
 21     {
 22       printf("\r%02d:%02d:%02d", m_hour, m_min, m_sec);
 23       fflush(stdout);//刷新输出缓冲区
 24       if(++m_sec == 60)
 25       { 
 26         m_sec = 0; 
 27         if(++m_min == 60)
 28         { 
 29           m_min = 0;
 30           if(++m_hour == 24)
 31           { 
 32             m_hour = 0;
 33           }
 34         }
 35       }
 36       sleep(1);
 37     }
 38   }
 39 
 40 private:
 41   int m_hour;
 42   int m_min;
 43   int m_sec;
 44 };
 45 
 46 int main(int argc, char *argv[])
 47 { 
 48   Clock t(time(NULL));
 49   t.run();
 50   return 0;
 51 }
运行结果：
22:29:04

4. 对象的创建和销毁
4.1 在栈区创建单个对象：

格式：
      类名  对象 （构造实参表）；
      类名  对象   =  类名（构造实参表）；//和上面等价 

4.2 在栈区创建多个对象（对象数组）（了解）：

格式：
	 类名 对象数组[元素个数] = {类名（构造实参表），...}；

4.3 在堆区创建单个对象

创建：
	类名 * 对象指针 = new 类名（构造实参表）；
销毁：
    delete 对象指针；

4.4 在堆区创建多个数组(了解)

创建：
	类名 * 对象指针　= new 类名[元素个数]｛类名（构造实参表），...｝；
销毁：
	delete []对象指针；

  1 #include <iostream>
  2 using namespace std;
  3 
  4 class Student
  5 {
  6 public:
  7   Student(const string& name, int age, int id)
  8   {
  9     cout <<"构造函数"<<endl;
 10     m_name = name;
 11     m_age = age;
 12     m_id = id;
 13   } 
 14   void who(void)
 15   {
 16     cout << "My name : "<<m_name<<" , age : "<<m_age<<", num : "<<m_id<<endl;
 17   } 
 18 private:
 19   string m_name;
 20   int m_age;
 21   int m_id;
 22 };
 23 
 24 int main()
 25 {
 26   //在栈区创建单个对象
 27   //Student s("rxl", 22, 12346);
 28   Student s = Student("red1", 22, 12346);
 29   s.who();
 30   
 31   //在栈区创建多个对象
 32   Student sarr[3] = {
 33     Student("red2", 18, 1109),
 34     Student("red3", 19, 1111),
 35     Student("red4", 20, 1112)
 36   };
 37   sarr[0].who();
 38   sarr[1].who();
 39   sarr[2].who();
 40   
 41   //在堆区中创建单个对象
 42   Student *ps = new Student("red5", 21, 1113);
 43   ps->who();//(*ps.who())
 44   delete ps;
 45   ps = NULL;
 46   
 47   //在堆区创建多个对象
 48   Student *parr = new Student[3]{
 49       Student("red6", 22, 1114),
 50       Student("red7", 23, 1115),
 51       Student("red8", 24, 1116)};
 52   parr[0].who();//(parr+0)->who();
 53   parr[1].who();//(parr+1)->who();
 54   parr[2].who();//(parr+2)->who();
 55   delete []parr;
 56   
 57   return 0;
 58 } 

5. 多文件编程
类的声明和定义可以分别放在不同的文件中：

1. 类的声明部分放在xx.h
2. 类的实现部分放在xx.cpp