- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
CFSDN坚持开源创造价值,我们致力于搭建一个资源共享平台,让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章C++OOP对象和类的详细讲解由作者收集整理,如果你对这篇文章有兴趣,记得点赞哟.
本文将从入门的角度介绍c++oop中的类和对象,事实上c++的类和对象远远不止本文所介绍的内容.
不过如果你感兴趣,我会把其他的内容逐一通过文章的形式介绍给你.
面向对象编程(oop)是一种特殊的、设计程序的概念性方法,c++通过一些特性改进了c语言,使得应用这种方法更加容易。下面是最重要的oop特性:
为了实现上述特性并把它们结合在一起,c++提供了类和对象.
我们首先来讨论一下oop。虽然c++偶尔讨论了oop,但更多的还是诸如c、pascal和basic等语言的标准过程性方法。下面看一个例子,它将揭示oop的核心观点与过程性编程的差别.
一般来说一场球赛的进球数量可以通过计算机来辅助计算例如每个选手的投球次数、命中率等等。如果这些由c++等利用oop编写程序,我们可以通过在一个函数中调用另一个函数,可以通过构建一个球队的类,或者建立一个球员的对象,通过调用函数的方式完成计算。而反观过程性编程,程序员需要用函数调用另一个函数来计算,用数组或变量等记录结果等等.
总之,如果采用过程性编程,首先考虑的是遵循的步骤,然后再考虑这些数据.
对于oop程序员,我们需要跟踪的就是球员,需要用一个对象表示整个选手的各个方面的表现.
采用oop,首先要从用户的角度考虑对象——描述对象所需的数据以及描述用户与数据交互所需的操作。完成接口描述后,需要确定如何实现接口和数据存储。最后,使用新的设计方案创建出程序.
生活中充满了复杂性,处理它们的方法就是简化和抽象.
数据抽象是指,只向外界提供关键信息,并隐藏其后台的实现细节,即只表现必要的信息而不呈现细节.
数据抽象是一种依赖于接口和实现分离的编程(设计)技术.
让我们举一个现实生活中的真实例子,比如一台电视机,您可以打开和关闭、切换频道、调整音量、添加外部组件(如喇叭、录像机、dvd 播放器),但是您不知道它的内部实现细节,也就是说,您并不知道它是如何通过缆线接收信号,如何转换信号,并最终显示在屏幕上.
因此,我们可以说电视把它的内部实现和外部接口分离开了,您无需知道它的内部实现原理,直接通过它的外部接口(比如电源按钮、遥控器、声量控制器)就可以操控电视.
现在,让我们言归正传,就 c++ 编程而言,c++ 类为数据抽象提供了可能。它们向外界提供了大量用于操作对象数据的公共方法,也就是说,外界实际上并不清楚类的内部实现.
例如,您的程序可以调用 sort() 函数,而不需要知道函数中排序数据所用到的算法。实际上,函数排序的底层实现会因库的版本不同而有所差异,只要接口不变,函数调用就可以照常工作.
类是一种将抽象转换为用户定义的c++工具,它将数据表示和操控数据的方法组合成一个整洁的包。下面我们来看看一个表示股票的类.
首先我们需要将股票的一股表示为一个基本单元,定义一个表示一股股票的类,然而,这意味着需要100个股票的单元才能构成100股。这将使工作量超标。相反,我们可以通过将某人持有的某种股票作为一个基本单元,数据表示中包含他所持有的股票数量.
具体地说,我们可以将执行的操作简化和限制为:
根据上述操作的需求来定义stock类的公共接口,我们可以通过调用接口来完成这些操作。而对于需要储存的信息,我们将它再次简化,我们最终将储存以下信息:
接口是一个共享的框架,共两个系统交互时使用。例如张三想要把银行里存的钱取走,需要在银行或者atm机取走他在银行系统里存的钱.
对于类,我们称为公共接口。在公共接口里,公共(public)是使用类的程序,而接口由程序员提供的调用类方法组成。例如,想要计算string对象包含多少个字符,我们无需打开对象,只需要使用其提供的size方法。方法size()便是用户与string类之间的公共接口.
c++ 在 c 语言的基础上增加了面向对象编程,c++ 支持面向对象程序设计。类是 c++ 的核心特性,通常被称为用户定义的类型.
类用于指定对象的形式,它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员.
定义一个类,本质上是定义一个数据类型的蓝图。这实际上并没有定义任何数据,但它定义了类的名称意味着什么,也就是说,它定义了类的对象包括了什么,以及可以在这个对象上执行哪些操作.
类定义是以关键字 class 开头,后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。例如,我们使用关键字 class 定义 box 数据类型,如下所示:
1
2
3
4
5
6
|
class
box {
public
:
double
length;
// 盒子的长度
double
breadth;
// 盒子的宽度
double
height;
// 盒子的高度
};
|
关键字public确定了类成员的访问属性。在类对象作用域内,公共成员在类的外部是可访问的。您也可以指定类的成员为 private或 protected.
类提供了对象的蓝图,所以基本上,对象是根据类来创建的。声明类的对象,就像声明基本类型的变量一样。下面的语句声明了类 box 的两个对象:
box box1; // 声明 box1,类型为 box box box2; // 声明 box2,类型为 box 。
对象 box1 和 box2 都有它们各自的数据成员.
类的对象的公共数据成员可以使用直接成员访问运算符.来访问.
下面这个例子能帮助你理解上述概念 。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
|
#include <iostream>
using
namespace
std;
class
box
{
public
:
double
length;
// 长度
double
breadth;
// 宽度
double
height;
// 高度
// 成员函数声明
double
get(
void
);
void
set(
double
len,
double
bre,
double
hei );
};
// 成员函数定义
double
box::get(
void
)
{
return
length * breadth * height;
}
void
box::set(
double
len,
double
bre,
double
hei)
{
length = len;
breadth = bre;
height = hei;
}
int
main( )
{
box box1;
// 声明 box1,类型为 box
box box2;
// 声明 box2,类型为 box
box box3;
// 声明 box3,类型为 box
double
volume = 0.0;
// 用于存储体积
// box 1 详述
box1.height = 5.0;
box1.length = 6.0;
box1.breadth = 7.0;
// box 2 详述
box2.height = 10.0;
box2.length = 12.0;
box2.breadth = 13.0;
// box 1 的体积
volume = box1.height * box1.length * box1.breadth;
cout <<
"box1 的体积:"
<< volume <<endl;
// box 2 的体积
volume = box2.height * box2.length * box2.breadth;
cout <<
"box2 的体积:"
<< volume <<endl;
// box 3 详述
box3.set(16.0, 8.0, 12.0);
volume = box3.get();
cout <<
"box3 的体积:"
<< volume <<endl;
return
0;
}
|
类的成员函数是指那些把定义和原型写在类定义内部的函数,就像类定义中的其他变量一样。类成员函数是类的一个成员,它可以操作类的任意对象,可以访问对象中的所有成员.
让我们看看之前定义的类 box,现在我们要使用成员函数来访问类的成员,而不是直接访问这些类的成员:
1
2
3
4
5
6
7
8
|
class
box
{
public
:
double
length;
// 长度
double
breadth;
// 宽度
double
height;
// 高度
double
getvolume(
void
);
// 返回体积
};
|
成员函数可以定义在类定义内部,或者单独使用范围解析运算符 :: 来定义。在类定义中定义的成员函数把函数声明为内联的,即便没有使用 inline 标识符。所以您可以按照如下方式定义 getvolume() 函数:
1
2
3
4
5
6
7
8
9
10
11
12
|
class
box
{
public
:
double
length;
// 长度
double
breadth;
// 宽度
double
height;
// 高度
double
getvolume(
void
)
{
return
length * breadth * height;
}
};
|
您也可以在类的外部使用范围解析运算符 :: 定义该函数,如下所示:
1
2
3
4
|
double
box::getvolume(
void
)
{
return
length * breadth * height;
}
|
在这里,需要强调一点,在 :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符(.),这样它就能操作与该对象相关的数据.
这里需要注意的是,定义在类中的成员函数缺省都是内联的,如果在类定义时就在类内给出函数定义,那当然最好。如果在类中未给出成员函数定义,而又想内联该函数的话,那在类外要加上 inline,否则就认为不是内联的。例如:
1
2
3
4
|
class
a
{
public
:
void
foo(
int
x,
int
y) { }
// 自动地成为内联函数
}
|
将成员函数的定义体放在类声明之中虽然能带来书写上的方便,但不是一种良好的编程风格,上例应该改成:
1
2
3
4
5
6
7
8
|
// 头文件
class
a
{
public
:
void
foo(
int
x,
int
y);
}
// 定义文件
inline
void
a::foo(
int
x,
int
y){}
|
inline 是一种用于实现的关键字 。
关键字 inline 必须与函数定义体放在一起才能使函数成为内联,仅将inline 放在函数声明前面不起任何作用.
如下风格的函数 foo 不能成为内联函数:
1
2
|
void
foo(
int
x,
int
y);
inline
void
foo(
int
x,
int
y) {}
// inline 与函数定义体放在一起
|
而如下风格的函数foo 则成为内联函数:
1
|
void
foo(
int
x,
int
y);
inline
void
foo(
int
x,
int
y) {}
// inline 与函数定义体放在一起
|
现在我们来梳理一下上面所说的程序,如下所示 。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
|
#include <iostream>
using
namespace
std;
class
box
{
public
:
double
length;
// 长度
double
breadth;
// 宽度
double
height;
// 高度
// 成员函数声明
double
getvolume(
void
);
void
setlength(
double
len );
void
setbreadth(
double
bre );
void
setheight(
double
hei );
};
// 成员函数定义
double
box::getvolume(
void
)
{
return
length * breadth * height;
}
void
box::setlength(
double
len )
{
length = len;
}
void
box::setbreadth(
double
bre )
{
breadth = bre;
}
void
box::setheight(
double
hei )
{
height = hei;
}
// 程序的主函数
int
main( )
{
box box1;
// 声明 box1,类型为 box
box box2;
// 声明 box2,类型为 box
double
volume = 0.0;
// 用于存储体积
// box 1 详述
box1.setlength(6.0);
box1.setbreadth(7.0);
box1.setheight(5.0);
// box 2 详述
box2.setlength(12.0);
box2.setbreadth(13.0);
box2.setheight(10.0);
// box 1 的体积
volume = box1.getvolume();
cout <<
"box1 的体积:"
<< volume <<endl;
// box 2 的体积
volume = box2.getvolume();
cout <<
"box2 的体积:"
<< volume <<endl;
return
0;
}
|
该程序被编译后执行,会得到下列输出 。
box1 的体积: 210box2 的体积: 1560 。
本篇文章就到这里了,希望能给你带来帮助,也希望您能够多多关注我的更多内容! 。
原文链接:https://blog.csdn.net/weixin_48985078/article/details/119859457 。
最后此篇关于C++OOP对象和类的详细讲解的文章就讲到这里了,如果你想了解更多关于C++OOP对象和类的详细讲解的内容请搜索CFSDN的文章或继续浏览相关文章,希望大家以后支持我的博客! 。
关闭。这个问题是opinion-based .它目前不接受答案。 想改善这个问题吗?更新问题,以便可以通过 editing this post 用事实和引文回答问题. 4年前关闭。 Improve t
就目前而言,这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持,但这个问题可能会引起辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开,visit the he
在面向对象的编程中,“基类”是派生其他类的类(http://en.wikipedia.org/wiki/Base_class)。 但是,基类的反面是什么?换句话说,什么是没有任何子类的类? 编辑:我正
关闭。这个问题需要更多focused .它目前不接受答案。 想改善这个问题吗?更新问题,使其仅关注一个问题 editing this post . 8年前关闭。 Improve this questi
据我了解,OOP 是大型项目最常用的范式。我也知道大系统的一些较小的子集使用其他范式(例如 SQL,它是声明性的),并且我也意识到在较低级别的计算 OOP 并不真正可行。但在我看来,通常更高级别的解决
就目前而言,这个问题不适合我们的问答形式。我们希望答案得到事实、引用资料或专业知识的支持,但这个问题可能会引发辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开,visit the
就目前而言,这个问题不适合我们的问答形式。我们希望答案得到事实、引用或专业知识的支持,但这个问题可能会引起辩论、争论、投票或扩展讨论。如果您觉得这个问题可以改进并可能重新打开,visit the he
最近听说OOP(Java)有9条规则。我只知道四种:抽象、多态、继承和封装。 OOP 还有更多规则吗? 最佳答案 看来您正在寻找的是 Principles of Object-Oriented Des
我曾经在一次采访中被问到“OOP 的 3 个主要概念是什么?”。我回答说,我认为有4个,如下: 继承 封装 抽象 多态性 我说得对吗? 最佳答案 语言要成为面向对象有3个要求: 仅支持封装(对象)的语
我有一个关于特定 OOP 问题的组织的简单问题。 假设我有一个地形类,里面充满了瓷砖。 Tile 类有多个派生类,即 Door。 Door 类有一个名为 open() 的方法,用于打开门,还有一个名为
就目前情况而言,这个问题不太适合我们的问答形式。我们希望答案得到事实、引用资料或专业知识的支持,但这个问题可能会引发辩论、争论、民意调查或扩展讨论。如果您觉得这个问题可以改进并可能重新开放,visit
我是 Go 的新手,然后我通过示例搜索了很多如何拥有带有静态函数/变量的静态类,例如 C#。但是,我找不到任何可以很好地回答它的东西。也许这个问题看起来很愚蠢,但我不喜欢不确定或不完全理解某事。 假设
我曾尝试搜索此问题的答案,但很难用语言表达,而且许多问题要么是关于如何创建类,要么是关于如何做非常具体的事情。我需要更多的实用概述 - 我是自学成才的,我了解对象是什么(以及如何创建它们),但我从未见
在开始编码之前,我通常会尝试在没有太多分析(没有图表)的情况下进行 TDD。通常我发现自己将一个类拆分为其他类以分离关注点。我想知道更深入的分析是否会阻止这种情况。我认为大部分面向对象分析无法预测其中
在阅读单例时,我发现这个解释是使用单例的原因: since these object methods are not changing the internal class state, we can
如这里所述 https://standardofnorms.wordpress.com/2012/09/02/4-pillars-of-object-oriented-programming/ 并作为
我是这个网站的新手,所以如果我在发布问题时做错了什么,请告诉我,以便我下次修复。 我很好奇从单个基类继承多个类是否是糟糕的 OOP 实践。这可能不太合理,所以我要详细说明一下。 例如,假设您正在设计一
我对“工厂相关”设计模式及其 OOP 实现的理解一直很简单。 一个 《工厂法》是类内部的一个方法,它有一个接口(interface)(或抽象类)作为返回类型,并根据一些内部逻辑构造实现该接口(inte
C# 中的“密封”关键字,Java 中的 Final。 因为我几乎从不创建任何图表并且我只使用已经完成的类(来自框架)我多年后仍然不知道为什么有人会“锁定”一个类所以它永远不会被扩展/继承。 它是有益
我正在研究面向对象的概念,抽象概念基本上被描述为对用户隐藏实现。因此,如果类中有一个成员函数并且我们为某些任务调用该函数,抽象表示用户不应该关心事情是如何完成的,而应该只知道正在完成什么。但即使在非面
我是一名优秀的程序员,十分优秀!