C++面向对象（一）——类与对象

最新推荐文章于 2023-05-03 16:10:24 发布
最新推荐文章于 2023-05-03 16:10:24 发布
阅读量4.2k 收藏 25
点赞数 8
分类专栏： C++ 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/flueky/article/details/51274732
版权

定义类

关键字class开头，后跟类的名称。类的主体被包在花括号中。类定义后必须跟着一个分号或列表。

class Line{
    private:
        double length;
    public:
        void setLength(double len);
        double getLength();
};

定义对象

声明类的对象，就像声明基本类型的变量一样。注意区分普通变量和引用变量的区别。

Line line1 ;//声明普通变量

Line* line2 = new Line;//声明指针变量
delete line2;

普通变量的内存占用由编译器去管理 。指针变量的内存占用由开发人员手动管理

访问数据成员

普通变量和指针变量访问数据成员的方式不一样，都只能访问公共成员变量和函数——用public 声明。

Line line1 ;
Line* line2 = new Line;

line1.setLength(10.0);
line2->setLength(11.1);

cout<<"line1 "<<line1.getLength()<<endl;
cout<<"line2 "<<line2->getLength()<<endl;

delete line2;

普通变量的公共成员用运算符（.）访问。指针变量的公共成员用运算符（->）访问。

类成员函数

类的成员函数是指那些把定义和原型写在类定义内部的函数，就像类定义中的其他变量一样。类成员函数是类的一个成员，它可以操作类的任意对象，可以访问对象中的所有成员。

成员函数可以定义在类定义内部，或者单独使用范围解析运算符（::）来定义。在类定义中定义的成员函数把函数声明为内联的，即便没有使用 inline 标识符。

class Line{
    private:
        double length;
    public:
        void setLength(double len);
        double getLength();
        void print(){//定义在类内部，也就是内联函数
            cout<<"line's length is "<<length<<endl;
            cout<<"called by print"<<endl;
        }
};

/**
 *类的外部使用范围解析运算符 :: 定义该函数
 */
void Line::setLength(double len){
    length = len;
}

double Line::getLength(){
    return length;
}

内联函数

内联函数从源代码层看，有函数的结构，而在编译后，却不具备函数的性质。内联函数不是在调用时发生控制转移，而是在编译时将函数体嵌入在每一个调用处。编译时，类似宏替换，使用函数体替换调用处的函数名。一般在代码中用inline修饰，但是能否形成内联函数，需要看编译器对该函数定义的具体处理。

//用关键字inline定义内联函数
inline void printLine(Line line){
    cout<<"line's length is "<<line.getLength()<<endl;
    cout<<"called by printLine"<<endl;
}

构造函数与析构函数

构造函数是一种特殊的成员函数，会在每次创建类的新对象时执行。析构函数函数则在每次删除所创建的对象时执行。

特征构造函数析构函数
名称类名~类名
返回类型无无
参数可以有参数不可以有参数
用途为某些成员变量设置初始值在跳出程序前释放资源
其他能够重载不能够重载

关于函数重载将在后后续博文中介绍

class Line{
    private:
        double length;
    public:
        void setLength(double len);
        double getLength();
        void print(){
            cout<<"line's length is "<<length<<endl;
            cout<<"called by print"<<endl;
        }
        Line();//没有参数的构造函数
        Line(double len);//带有参数的构造函数
        ~Line();//析构函数
};

Line::Line(){
    length=0;
    cout<<"object is created "<<length<<endl;

}

Line::Line(double len){
    length = len;
    cout<<"object is created "<<length<<endl;
}

Line::~Line(){
    cout<<"object is deleted"<<endl;
}

int main(int argc, char *argv[]) {

    Line line1(12) ;//调用有参数的构造函数
    Line* line2 = new Line;//调用无参数的构造函数

    line1.setLength(10.0);
    line2->setLength(11.1);

    cout<<"line1 "<<line1.getLength()<<endl;
    cout<<"line2 "<<line2->getLength()<<endl;

    delete line2;//调用析构函数。程序结束时编译器自动释放line1 的资源，再次调用析构函数一次
}

运行结果

object is created 12
object is created 0
line1 10
line2 11.1
object is deleted
object is deleted

分析运行结果得知，定义两个变量，构造函数和析构函数各调用两次。其中，指针变量需要手动delete才能调用析构函数。有兴趣的可以自行验证。

拷贝构造函数

一种特殊的构造函数，它在创建对象时，是使用同一类中之前创建的对象来初始化新创建的对象。
拷贝构造函数通常用于：

  1. 通过使用另一个同类型的对象来初始化新创建的对象。
  2. 复制对象，把它作为参数传递给函数。
  3. 复制对象，并从函数返回这个对象

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。定义拷贝构造函数，参照如下形式：

classname (const classname &obj) {
    // 构造函数的主体
}

给Line类添加上拷贝构造函数

class Line{
    private:
        double length;
    public:
        void setLength(double len);
        double getLength();
        void print(){
            cout<<"line's length is "<<length<<endl;
            cout<<"called by print"<<endl;
        }
        Line();//没有参数的构造函数
        Line(double len);//带有参数的构造函数
        ~Line();//析构函数
        Line(const Line &obj);//拷贝构造函数
};

Line::Line(const Line &obj){
    cout<<"copy Line"<<endl;
    length = obj.length;
}

int main(int argc, char *argv[]) {

    Line line1(12) ;//调用有参数的构造函数
    Line* line2 = new Line;//调用无参数的构造函数

    line1.setLength(10.0);
    line2->setLength(11.1);

    printLine(line1);

    cout<<"line1 "<<line1.getLength()<<endl;
    cout<<"line2 "<<line2->getLength()<<endl;

    delete line2;//调用析构函数。程序结束时编译器自动释放line1 的资源，再次调用析构函数一次
}
object is created 12
object is created 0
copy Line
line's length is 10
called by printLine
object is deleted
line1 10
line2 11.1
object is deleted
object is deleted

眼尖的伙伴也许发现了这里调用了三次析构函数。分析第三行到第6行的输出，调用函数printLine首先会调用拷贝构造函数给形参复初始化，再执行printLine的函数体，最后释放形参暂用的资源。

友元函数

  • 友元可以是一个函数，该函数被称为友元函数。友元也可以是一个类，该类被成为友元类。在这种情况下，整个类及其所有成员都是友元。
  • 友元函数是定义在类的外部却可以访问类的内部成员（private 和protected）。友元函数的原型在类的内部定义，但是不是类的成员函数。通常用关键字 friend 修饰声明的函数为一个类的友元。
class Line{
    private:
        double length;
    public:
        void setLength(double len);
        double getLength();
        void print(){
            cout<<"line's length is "<<length<<endl;
            cout<<"called by print"<<endl;
        }
        Line();//没有参数的构造函数
        Line(double len);//带有参数的构造函数
        ~Line();//析构函数
        Line(const Line &obj);//拷贝构造函数

        friend void print(Line line);//定义为line类的友元函数
};

inline void printLine(Line line){
    cout<<"line's length is "<<line.getLength()<<endl;
    cout<<"called by printLine"<<endl;
}

//printf不是任何类的成员函数，因此不需要修饰符::
void printf(Line line){
    //友元函数可以直接访问该类的任何成员
    cout<<"line's length is "<<line.length<<endl;
    cout<<"called by printLine"<<endl;
}

对比友元函数、内联函数、成员函数的定义。成员函数和友元函数可以访问类的内部成员。但是友元函数必须基于类的对象访问类的内部成员。友元函数和内联函数不需要范围解析运算符，因为他们不属于类的成员函数。

this指针

每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此，在成员函数内部，它可以用来指向调用对象。
友元函数没有 this 指针，因为友元不是类的成员。只有成员函数才有 this 指针。

Line Line::changeLine(double length){
    this->length = length;//第一个length是类的成员变量，第二个length是形参
    cout<<"line's length is "<<this->length<<endl;
    cout<<"called by changeLine"<<endl;
    return *this;//返回自己的地址
}

int main(int argc, char *argv[]) {

    Line line1(12) ;//调用有参数的构造函数
    Line* line2 = new Line;//调用无参数的构造函数

    line1.setLength(10.0);
    line2->setLength(11.1);

    printLine(line1);

    cout<<"line1 "<<line1.getLength()<<endl;
    cout<<"line2 "<<line2->getLength()<<endl;

    Line line3 = line2->changeLine(23);
    cout<<"line3 "<<line3.getLength()<<endl;

    delete line2;//调用析构函数。程序结束时编译器自动释放line1,line3的资源，再次调用析构函数两次
}
object is created 12
object is created 0
copy Line
line's length is 10
called by printLine
object is deleted
line1 10
line2 11.1
line's length is 23
called by changeLine
copy Line
line3 23
object is deleted
object is deleted
object is deleted

分析第9~13行的输出，return *this;会再次生成一个line对象。因此后续会依次释放line1、line2、line3 的资源。

静态成员

在类的定义中，用static 关键字把类的成员定义为静态的。无论创建多少个对象，静态成员都只有一个副本。访问静态成员的方式：classname :: staticmember。静态成员可以是成员变量也可以是成员函数。

//完整版Line类

#include <iostream>

using namespace std;

class Line{
    private:
        double length;
        static int objcount;//声明静态成员变量
    public:
        void setLength(double len);
        double getLength();
        void print(){
            cout<<"line's length is "<<length<<endl;
            cout<<"called by print"<<endl;
        }
        Line();//没有参数的构造函数
        Line(double len);//带有参数的构造函数
        ~Line();//析构函数
        Line(const Line &obj);//拷贝构造函数

        friend void print(Line line);//定义为line类的友元函数

        Line changeLine(double length);

        static int getCount();
};

int Line::objcount = 0;//定义并初始化静态成员变量

Line::Line(){
    length=0;
    cout<<"object is created "<<length<<endl;
    objcount++;
    cout<<objcount<<" objects left"<<endl;
}
Line::Line(double len){
    length = len;
    cout<<"object is created "<<length<<endl;
    objcount++;
    cout<<objcount<<" objects left"<<endl;
}

Line::~Line(){
    cout<<"object is deleted"<<endl;
    objcount--;
    cout<<objcount<<" objects left"<<endl;
}

int Line::getCount(){
    return objcount;
}

Line::Line(const Line &obj){
    cout<<"copy Line"<<endl;
    length = obj.length;
    objcount++;
    cout<<objcount<<" objects left"<<endl;
}

void Line::setLength(double len){
    length = len;
}

double Line::getLength(){
    return length;
}

inline void printLine(Line line){
    cout<<"line's length is "<<line.getLength()<<endl;
    cout<<"called by printLine"<<endl;
}

//printf不是任何类的成员函数，因此不需要修饰符::
void print(Line line){
    //友元函数可以直接访问该类的任何成员
    cout<<"line's length is "<<line.length<<endl;
    cout<<"called by printLine"<<endl;
}

Line Line::changeLine(double length){
    this->length = length;
    cout<<"line's length is "<<this->length<<endl;
    cout<<"called by changeLine"<<endl;
    return *this;
}

int main(int argc, char *argv[]) {

    Line line1(12) ;//调用有参数的构造函数
    Line* line2 = new Line;//调用无参数的构造函数

    line1.setLength(10.0);
    line2->setLength(11.1);

    printLine(line1);

    cout<<"line1 "<<line1.getLength()<<endl;
    cout<<"line2 "<<line2->getLength()<<endl;

    Line line3 = line2->changeLine(23);
    cout<<"line3 "<<line3.getLength()<<endl;
    cout<<"obj count is "<<Line::getCount()<<endl;
    delete line2;//调用析构函数。程序结束时编译器自动释放line1 的资源，再次调用析构函数一次

}
object is created 12
1 objects left
object is created 0
2 objects left
copy Line
3 objects left
line's length is 10
called by printLine
object is deleted
2 objects left
line1 10
line2 11.1
line's length is 23
called by changeLine
copy Line
3 objects left
line3 23
obj count is 3
object is deleted
2 objects left
object is deleted
1 objects left
object is deleted
0 objects left

最后，自行分析程序运行结果。

小飞哥0217
关注
  • 8
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++面向对象程序设计教程——课件PPT
10-19
C++面向对象程序设计教程（第3版）——陈维兴、林小茶编著 清华大学出版社 这个是对应的PPT课件，文件为压缩包，里面每章一个PPT文件。
【C++核心】一文理解C++面向对象（超级详细！）
热门推荐
数据知道的博客
07-05 1万+
C++面向对象的三大特性为：封装、继承、多态C++认为万事万物都皆为对象，对象上有其属性和行为例如：​ 人可以作为对象，属性有姓名、年龄、身高、体重…，行为有走、跑、跳、吃饭、唱歌…​ 车也可以作为对象，属性有轮胎、方向盘、车灯…,行为有载人、放音乐、放空调…​ 具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类封装是C++面向对象三大特性之一，封装的意义：封装意义一：​ 在设计类的时候，属性和行为写在一起，表现事物语法： 示例1： 设计一个圆类，求圆的周长示例代码： 示例2： 设计一个学生类
C++面向对象
qq_45806136的博客
02-13 3503
*从存储空间的角度考虑：**构造函数是在实例化对象的时候进行调用，如果此时将构造函数定义成虚函数，需要通过访问该对象所在的内存空间才能进行虚函数的调用（因为需要通过指向虚函数表的指针调用虚函数表，虽然虚函数表在编译时就有了，但是没有虚函数的指针，虚函数的指针只有在创建了对象才有），但是此时该对象还未创建，便无法进行虚函数的调用。所以构造函数不能定义成虚函数。**从使用的角度考虑：**虚函数是基类的指针指向派生类的对象时，通过该指针实现对派生类的虚函数的调用，构造函数是在创建对象时自动调用的。
【C++】面向对象
Tianzhenchuan的博客
05-01 665
C++中类的关键字既可以用class，也可以用struct。常用的是class。类中的元素称为类的成员：类中的数据称为类的属性或者成员变量;类中的函数称为类的方法或者成员函数。int _age;return 0;类的两种定义方式①声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
【C++】面向对象基础篇
我宣布个事的博客
01-10 1493
本文通过代码示例，基本涵盖所有C++基础内容
Visual C++ 面向对象编程教程——王育坚
01-20
学习MFC的不可多得的好教材，幻灯片形式，配合例题及讲解，试试看吧
C++面向对象程序设计——复习大纲.pdf
09-30
C++面向对象程序设计——复习大纲.pdf
面向对象程序设计——谭浩强
11-11
谭浩强一直以来的风格，浅显易懂，面向对象程序设计！
C/C++填坑笔记——继承、重载和多态
沉迷单车的追风少年
02-03 676
目录 继承 语法: 访问控制和继承 多继承 重载 函数重载 运算符重载 多态 虚函数 继承 继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。 当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成...
详解面向对象，c++面向对象是什么？详解构造函数、析构函数、运算符重载
fanzhaokai0420的博客
08-07 1460
详解c++面向对象，总结构造函数、析构函数与运算符重载。
C++ 面向对象程序设计
2201_75772333的博客
05-03 3021
在面向对象的思想中，我们把对象作为程序的基本单元，一个对象包含了数据和操作数据的函数。当然，一个应用程序会包含多个对象，通过多个对象的相互配合即可实现应用程序所需的功能，这样当应用程序功能发生变动时，只需要修改个别对象就可以了，使代码更容易维护。面向对象的程序设计思想可以帮助我们创建结构良好的，可复用的代码，更好地描述和理解真实世界的问题。封装可以隐藏对象的内部表示，只通过对象的方法暴露必要的操作和功能。这使得新类可以复用和扩展已存在的类的代码，提高了代码的复用性，并能够表达类之间的"is-a"关系。
C++之面向对象（一）
weixin_60535956的博客
05-26 1883
面向对象编程，即面对客观世界存在的对象进行编程，是一种必备的理解思路。
C++ ——面向对象程序设计
prtinf48_9的博客
08-29 5866
是指包含后面所跟的内容，是input output stream的缩写，意思是输入输出流。所以#include定义的就是你要输入和输出的内容。
C++面向对象——类/抽象 图解
最新发布
09-03
- *1* *3* [面向对象——类和对象](https://blog.csdn.net/shouyeren_st/article/details/126210622)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值