C++笔记二：类和对象

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

2024-09-19 23:58:40 215人阅读

　　　　　　　　　　　　　　　　　　　　　　类和对象

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++笔记二：类和对象

声明：以上内容来自用户投稿及互联网公开渠道收集整理发布，本网站不拥有所有权，未作人工编辑处理，也不承担相关法律责任，若内容有误或涉及侵权可进行投诉：投诉/举报工作人员会在5个工作日内联系你，一经查实，本站将立刻删除涉嫌侵权内容。

联系
我们

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

C++笔记二：类和对象

看完仍有疑问？有类似问题直接问程序猿