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;
缺点：面向对象的基本原则包括封装性和信息隐藏，而由于友元可以访问其他类的私有成员，这是对封装原则的一个破坏。因此使用友元的时候要特别慎重。

时间： 2024-08-25 12:05:05

C++笔记二：类和对象的相关文章

Objective－C 笔记二 类、对象和方法

对象就是一个物件.面向对象的程序设计可以看成一个物件和你想对它做的事情.这与C语言不同,C语言通常称为过程性语言.在C语言中,通常是先考虑要做什么,然后才关注对象,这几乎总是与面相对象的思考过程相反. 在面向对象的用语中,(这里我们以汽车作为对象)你的汽车是汽车的一个实例.car就是类的名称,这个实例就是从该类创建的.因此,每制造一辆新汽车,就会创建汽车类的一个新实例,而且汽车的每个实例都称为一个对象. 对象 使用对象执行的操作 你的汽车 驾驶 加油 洗车 维修 每个实例或对象不仅包含从制造商那

Java学习笔记-3.类与对象

一.面向对象程序设计 1.概念:   OOA:面向对象的分析,将现实世界进行抽象的分析 OOD:面向对象的设计 OOP:面向对象的程序 2.面向对象的特点: (1)封装性:一是把对象的全部状态和行为结合在一起,形成一个不可分割的整体,对象的私有属性只能由对象的行为来修改和读取 二是尽可能隐藏对象的内部细节,与外界的联系只能够通过外部接口来实现 (2)继承性:特殊类的对象拥有其一般类的属性和行为 (3)多态性:指同一个实体同时具有多种形式,体现在不同的对象可以根据相同的消息产生各自不同的动作 二.

iOS开发之oc（回顾笔记）--类与对象（1）

理论是枯燥的,所以有点长.哈哈哈~ 要学习一门语言,我们首先得了解它,那么 [什么是OC] objectiv-c  简称 OC,是一门基于C语言为基础编写而成的面向对象的语言.完全兼容C语言:可以在OC代码中混入C语言代码,甚至是C++代码: 可以使用OC开发Mac OS X平台和iOS平台的应用程序. (一)首先,先了解一下面向过程和面向对象: [面向过程] 1.面向过程的语言所有语句都是祈使句  2.面向过程的语言是数学逻辑的映射 3.面向过程语言的程序 = 数据 + 算法 C语言就是一门面

阿花宝宝 Java基础笔记 之 类和对象

一,对象对象:客观存在的事物就是对象对象包含:属性(特征)  和   方法(操作)二,类类:具有相同属性和方法的一组对象的集合.类和对象的关系就是抽象和具体的关系.类是对象的集合,对象是类的实例. 定义一个类的步骤1.定义类名 2.编写类的属性3.编写类的方法public class  <类名>{ //定义属性部分 定义变量来描述类所具有的属性,这些变量称为类的成员变量.  //定义方法部分 访问修饰符  返回值类型 方法名(){  方法体 }}创建和使用对象类名 对象名=new 类名(); 

Objective-C学习笔记_类和对象

一 Objective-C概述 二 面向对象编程OOP Object Oriented Programming 三 类和对象 OC中类的定义 接口部分 实现部分 类和文件 创建对象 使对象 四 实例变量操作 一 Objective-C概述 Cocoa和Objective-C是苹果公司Mac OS X操作系统的核心.1980年初,Brad Cox发明了Objective-C,意将流行的.可移植的C语言和Smalltalk语言结合在一起:1985年,Steve Jobs成立NeXT公司,NeXT选择

Java学习笔记1——类和对象

面向对象 对象:万物皆对象 面向对象 类:模子,属性+方法,类是对象的类型,是具有相同属性和方法的一组对象的集合 对象属性:对象拥有的各种特征,"对象有什么" 对象方法:对象执行的操作,"对象能干什么" 类与对象的关系/区别:类是抽象的,仅仅是模版:对象是看得到,摸得着的具体实体.例如:'手机'类,对象为iPhone6,Lumia920 Java中的类 定义类:Java程序都以类class为组织单元 创建一个对象 //1.定义一个类 public class Tel

《PHP Manual》阅读笔记3 —— 类与对象

1.PHP 中的所有函数和类都具有全局作用域,可以定义在一个函数之内而在之外调用,反之亦然. PHP 不支持函数重载,也不可能取消定义或者重定义已声明的函数. 当一个函数是有条件被定义时,必须在调用函数之前定义. 函数名是大小写无关的,不过在调用函数的时候,使用其在定义时相同的形式是个好习惯. 2.默认值必须是常量表达式,不能是诸如变量,类成员,或者函数调用等. 注意当使用默认参数时,任何默认参数必须放在任何非默认参数的右侧:否则,函数将不会按照预期的情况工作.考虑下面的代码片断: <?php

学习笔记——Java类和对象

今天学习了Java的类和对象的相关知识,由于Java面向对象的编程的思想和C++几乎一样,所以需要更多的关注Java的一些不同之处. 1.类 1.1 在类这一块,除了基本的成员变量,成员方法,构造函数等外,需要掌握三种权限修饰符的区别,并会合理使用(private限制了权限只在本类,protected限定了权限只在包内). 1.2 静态常量.变量.方法:static修饰.我们可以使用“类名.静态类成员”来调用,如: public class StaticTest{ static double P

Objective-C学习笔记______类和对象的使用

// // main.m // 类和对象 // // Created by apple on 15/5/30. // Copyright (c) 2015年 apple. All rights reserved. // #import <Foundation/Foundation.h> @interface Computer : NSObject //定义电脑这么一个类 { @public NSString *namec; //定义一个NSString类型名为namec的指针,用于指向一个字符

Java复习(二)类与对象的基本概念

2.1面向对象的程序设计方法概述 对象 程序中: 一切皆是对象 都具有标识,属性和行为 通过一个或多个变量来保存其状态 通过方法实现他的行为 类 将属性及行为相同或相似的对象归为一类 类可以看成是对象的抽象,代表了此类对象所具有的共有属性和行为 在面向对象的程序设计中,每一个对象都属于某个特定的类 2.1.1抽象 过程抽象 数据抽象 2.1.2封装 2.1.3继承 Java仅支持单继承 2.1.4多态 2.2类与对象 2.2.1类的声明 声明形式 [public] [abstract|final