首页 > 代码库 > C++笔记二:类和对象

C++笔记二:类和对象

                      类和对象

1:面向对象基础

2: 定义类和对象

3: 类和对象的使用

4: 构造函数和析构函数

5: this指针和复制构造函数

6: static静态成员

7: const对象和const成员

8: friend友元

----------------------------------------------------------------------------------------------------------------------

(1)面向对象基础 

一、什么是面向对象程序设计

   面向对象的程序设计:把面向对象的思想应用到软件开发中,并指导开发维护软件。

   有关概念:对象、 封装与信息隐藏、抽象继承与重用、 多态性

二、面向对象程序设计的特点
 
三、面向对象软件开发步骤
   1.面向对象分析(Object oriented analysis)
   2.面向对象设计(Object oriented design)
   3.面向对象编程(Object oriented programming) 

----------------------------------------------------------------------------------------------------------------------

 (2)定义类和对象

类是对象的抽象,而对象是类的具体实例
 
 1.定义类 
 定义结构体的方法:
struct Student
{
   char name[128];
   int age;
   char add[128];
};
 
类的定义格式:
class  类名
{  
   private :
            成员数据;
            成员函数;
     public :
            成员数据;
        成员函数;
    protected:
      成员数据;
      成员函数;
};
 class 类名 对象名
 类名 对象名
2.定义对象

  Student stu;

3.类的成员函数

int Student::getAge()               //在类的外部进行成员函数的定义,需要加上限制符

  return age;

}

注意: .h    .cpp  分离

   一般在类的内部进行成员函数的申明,在类的外部进行类的定义

    需要加上类的限制符::作用域 

----------------------------------------------------------------------------------------------------------------------

 (3)类和对象的使用

1.对象成员的引用
程序中访问对象成员有以下三种方法:
 (1)通过对象名和成员访问运算符"."来访问。

  技术分享

  (2)通过指向对象的指针来访问

  技术分享        //指针间接对变量进行运算    *p=&a,间接对a的地址进行运算

  (3)通过引用来访问

  技术分享         //  引用直接对变量进行运算   &b=a,直接对a变量进行运算

2. 类声明和成员函数实现的分离
    类的定义和成员函数的实现一般不放在一起,而是放在不同的文件中。   

   类的成员函数的申明在.h头文件

       类的成员函数的定义在.cpp文件 

  技术分享

3.一个简单例子

  技术分享

头文件:Time.h

 1 #ifndef TIME_H
 2 #define TIME_H
 3 //#include"Date.h"
 4 #include<iostream>
 5 using namespace std;
 6 
 7 class CTime
 8 {
 9 public:
10     CTime();
11     CTime(int hour, int minute, int second = 0);
12     CTime(int value);
13     CTime(CTime& time);
14     virtual ~CTime();            //析构函数可以是虚函数,因为此时对象已经生成,虚函数需要虚函数表和虚函数指针,指针指向虚函数表
15     void setHour(int hour);
16     void setMinute(int minute);
17     void setSecond(int second);
18 
19     virtual int getHour();
20     int getMinute();
21     int getSecond();
22     CTime operator+(CTime& time);
23     CTime& operator=(CTime& time);
24     bool operator==(CTime& time);
25     bool operator>(CTime& time);
26     CTime operator++();
27     CTime operator++(int);
28     operator int();
29 
30     friend istream& operator>>(istream& input, CTime& time);
31 private:
32     int m_nHour;
33     int m_nMinute;
34     int m_nSecond;
35 };
36 
37 #endif

CPP文件:Time.cpp

  1 #include"Time.h"
  2 #include<iostream>
  3 using namespace std;
  4 
  5 CTime::CTime()
  6 {
  7     m_nHour = 0;
  8     m_nMinute = 0;
  9     m_nSecond = 0;
 10 }
 11 
 12 CTime::~CTime()
 13 {
 14 }
 15 
 16 CTime::CTime(int value)
 17 {
 18     m_nHour = m_nMinute = 0;
 19     m_nSecond = value;
 20 }
 21 
 22 CTime::CTime(int hour, int minute, int second)
 23 {
 24     m_nHour = hour;
 25     m_nMinute = minute;
 26     m_nSecond = second;
 27 }
 28 
 29 CTime::CTime(CTime& time)
 30 {
 31     m_nHour = time.m_nHour;
 32     m_nMinute = time.m_nMinute;
 33     m_nSecond = time.m_nSecond;
 34 }
 35 
 36 void CTime::setHour(int hour)
 37 {
 38     m_nHour = hour;
 39 }
 40 
 41 void CTime::setMinute(int minute)
 42 {
 43     m_nMinute = minute;
 44 }
 45 
 46 void CTime::setSecond(int second)
 47 {
 48     this->m_nSecond = second;
 49 }
 50 
 51 int CTime::getHour()
 52 {
 53     return m_nHour;
 54 }
 55 
 56 int CTime::getMinute()
 57 {
 58     return m_nMinute;
 59 }
 60 
 61 int CTime::getSecond()
 62 {
 63     return m_nSecond;
 64 }
 65 
 66 CTime CTime::operator+(CTime& time)
 67 {
 68     int nHour = 0, nMinute = 0;
 69     int nSecond = this->m_nSecond + time.m_nSecond;
 70     if(nSecond > 60)
 71     {
 72         nMinute ++;
 73         nSecond -= 60;
 74     }
 75 
 76     nMinute += (this->m_nMinute + time.m_nMinute);
 77     if(nMinute > 60)
 78     {
 79         nHour++;
 80         nMinute -= 60;
 81     }
 82 
 83     nHour += (this->m_nHour + time.m_nHour);
 84     if(nHour > 24)
 85     {
 86         nHour -= 24;
 87     }
 88 
 89     return CTime(nHour, nMinute , nSecond);
 90 }
 91 
 92 CTime& CTime::operator=(CTime& time)
 93 {
 94     if(this == &time)
 95     {
 96         return *this;
 97     }
 98 
 99     m_nHour = time.m_nHour;
100     m_nMinute = time.m_nMinute;
101     m_nSecond = time.m_nSecond;
102 
103     return *this;
104 }
105 
106 bool CTime::operator==(CTime& time)
107 {
108     if(m_nHour == time.m_nHour
109         && m_nMinute == time.m_nMinute
110         && m_nSecond == time.m_nSecond)
111     {
112         return true;
113     }
114 
115     return false;
116 }
117 
118 bool CTime::operator>(CTime& time)
119 {
120     if(m_nHour > time.m_nHour)
121     {
122         return true;
123     }
124     else if(m_nHour < time.m_nHour)
125     {
126         return false;
127     }
128     else
129     {
130         if(m_nMinute > time.m_nMinute)
131         {
132             return true;
133         }
134         else if(m_nMinute < time.m_nMinute)
135         {
136             return false;
137         }
138         else
139         {
140             if(m_nSecond > time.m_nSecond)
141             {
142                 return true;
143             }
144             else
145             {
146                 return false;
147             }
148         }
149     }
150 
151     return false;
152 }
153 
154 CTime CTime::operator++()
155 {
156     CTime time(0, 0, 1);
157     *this = *this + time;
158     return *this;
159 }
160 
161 CTime CTime::operator++(int)
162 {
163     CTime time = *this;
164     CTime time2(0, 0, 1);
165     *this = *this + time2;
166     return time;
167 }
168 
169 CTime::operator int()
170 {
171     return m_nHour * 60 * 60 + m_nMinute * 60 + m_nSecond;
172 }

main函数:main.cpp

 1 #include<iostream>
 2 #include"Time.h"
 3 #include"CurrentTime.h"
 4 #include"DateTime.h"
 5 using namespace std;
 6 
 7 istream& operator>>(istream& input, CTime& time)
 8 {
 9     cin>>time.m_nHour>>time.m_nMinute>>time.m_nSecond;
10     return input;
11 }
12 
13 ostream& operator<<(ostream& output, CTime& time)
14 {
15     cout<<time.getHour()<<time.getMinute()<<time.getSecond()<<endl;
16     return output;
17 }
18 
19 
20 int main()
21 {
22     CCurrentTime currentTime;
23     CTime* pTime = &currentTime;
24     pTime->getHour();
25 
26     return 0;
27 }

----------------------------------------------------------------------------------------------------------------------

 (4)构造函数和析构函数

C++提供构造函数来处理对象的初始化。
构造函数是一种特殊的成员函数,不需要用户来调用,定义对象时被自动执行。
构造函数名字与类名相同,无返回类型。
可以由用户自己定义实现,根据需要设计对数据成员进行初始化
构造函数:无返回值,void也不行

  默认参数构造函数

  带参数的构造函数

  构造函数的重载

    复制构造函数 
析构函数:
this指针:指向本对象

注意:构造函数和析构函数的执行对应顺序相反,一一对应的关系。

----------------------------------------------------------------------------------------------------------------------

 (5)this指针和复制构造函数

this指针是指向本类对象的指针,它作为参数传递给成员函数
由编译器自动实现,程序员不必人为的在形参中添加this指针。
 
复制构造函数一种特殊的构造函数,在创建一个新的对象时将其他对象作为参数时,
编译器将会调用复制构造函数。不提供时使用默认构造函数。默认构造函数内部各个成员变量赋值。
创建之后,新对象是老对象的副本二者值相同。但具有不同的存储空间。copy构造函数,但需要新的存储空间。
形式:
  CTime(CTime& time);               //参数构造函数是传引用的方式,避免copy

或者
  CTime time;
  CTime time2(time);
调用复制构造函数的时机:
1.以其他对象作为参数创建新对象时。
2.类对象(传值)作为函数参数时。
3.类对象作为函数返回值时。

----------------------------------------------------------------------------------------------------------------------

 (6)静态成员static:需要在类的内部申明,外部定义,同样需要两种访问方式

静态数据成员
  1:以static开头。静态数据成员为各个对象共有,不属于某个具体的对象,所有对象都可以对它进行引用,都可以读取和修改。

  2:若一个对象修改了该静态成员的值,则在其他各个对象中该数据成员的值都会同时改变
  3:定义类时就为静态数据成员分配空间,不随对象的建立而分配空间。
  4:定义完类之后就可以引用
引用方法: 
         1:类名::静态成员
         2:对象名.静态成员
 

注意:在类内的static静态数据成员仅仅是对该成员的声明,同时还需要在类外部进行定义

   因为其优先于对象存在,所以需要在类的内部申明,外部定义。
 
静态成员函数
  在声明成员函数时在函数前添加static关键字就定义了静态成员函数。
  与静态数据成员一样,静态成员函数也是类的一部分。两种引用的方法。
 
静态成员函数一般是为了处理静态的数据成员。
与一般成员函数的区别:非静态成员函数有this指针,静态成员函数没有this指针。
因为它可以在未定义类对象时就可以引用。因此静态成员函数不能访问本类中的非静态成员。(成员函数和数据成员)。

----------------------------------------------------------------------------------------------------------------------

 (7)const对象和const成员:需要初始化列表来初始化const成员变量  

  1.const对象 

  定义类对象时可以将其指定为const对象。  

  定义后const对象不能再被修改。  

  const对象不能调用非const类型的成员函数。只能调用const成员函数  

  const 类名 对象  

  类名 const 对象名

  2.const成员变量
    在类内部使用const关键字来声明const数据成员。const数据成员的值不能被修改。
    初始化时比较特殊,只能通过初始化列表初始化。不能在构造函数里赋值。

    const int m_nNumber;         //定义const变量,不能直接初始化;
    初始化列表:构造函数初始化列表以一个冒号开始,接着是以逗号分隔的数据成员列表,每个数据成员后面跟一个放在括号中的初始化式。

    如果存在多个构造函数,需要在每一个构造函数都要初始化

    技术分享技术分享技术分享

  3.const成员函数
  const成员函数只能被const对象引用const成员函数内可以引用const数据成员,也可以引用非const数据成员,但不能修改非const数据成员的值。但不能调用非const成员函数。

  技术分享

  需要在成员函数后面加上const;

  int getNum() const ;

----------------------------------------------------------------------------------------------------------------------

 (8)友元:friend关键字

C++中可以使用friend关键字来将函数、类声明为某个类的友元。
友元包括友元函数和友元类
友元具有一些特权,可以访问private的成员。
友元只能授予,不能索取,单向,不能传递。
1.友元函数
在类体中使用friend关键字对友元函数进行声明:
将非成员函数声明为友元:
friend void func();          //func为非成员函数,不属于任何类
将其他类的成员函数声明为友元:
friend void CTime::getNum();   //getNum为CTime类的成员。
 
2.友元类
在类体中使用friend关键字将某类声明为自己的友元类。
friend CTime;
缺点:面向对象的基本原则包括封装性和信息隐藏,而由于友元可以访问其他类的私有成员,这是对封装原则的一个破坏。因此使用友元的时候要特别慎重。


 

 

C++笔记二:类和对象