首页 > 其他分享 >类和对象（上）

类和对象（上）

时间：2024-08-09 20:28:00浏览次数：7  
标签：ps 成员 对象 top int Init void

c++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

文章目录

一、类的定义

1.1 类定义格式

class className
 {
 	// 类体：由成员函数和成员变量组成
 };  // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。
类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

1.定义在类里面的成员函数默认为inline。

2.为了区分成员变量，一般习惯上成员变量会增加一个特殊标识，如成员变量前面或者后面加_或者m开头，注意c++中这个并不是强制的，只是一些惯例。如下：

#include<iostream>
using namespace std;
class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Init(2024,8,9);

	return 0;
}

3.C++中struct也可以定义类，C++兼容C中struct的⽤法，同时struct升级成了类，明显的变化是struct中可以定义函数，⼀般情况下我们还是推荐⽤class定义类。如下：

//c++升级struct为类,类里面可以定义函数,struct名称就可以代表类型
// 
// c++兼容c语言的写法

//这是c语言的写法，c++中也兼容c中struct的用法。
typedef struct ListNodeC
{
	struct ListNodeC* next;
	int val;
}ListNode;

//不再需要typedef，ListNodeCpp就可以代表类型
struct ListNodeCpp
{
	void Init(int x)
	{
		next = nullptr;
		val = x;
	}
	ListNodeCpp* next;
	int val;
};

1.2 访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性的将其接口提供给外部的用户使用。
在这里插入图片描述

  1. public修饰的成员在类外可以直接被访问；
  2. protected和private修饰的成员在类外不能直接被访问，protected和private是⼀样的，以后继承章节才能体现出他们的区别。
  3. 访问权限作⽤域从该访问限定符出现的位置开始直到下⼀个访问限定符出现时为⽌，如果后⾯没有访问限定符，作⽤域就到}即类结束。
  4. class定义成员没有被访问限定符修饰时默认为private，struct默认为public。
  5. ⼀般成员变量都会被限制为private/protected，需要给别⼈使⽤的成员函数会放为public。
class Stack
{
public:
	void Init(int n = 4)
	{
		a = (int*)malloc(sizeof(int) * n);
		if (a == nullptr)
		{
			perror("error");
			return;
		}
		capacity = n;
		top = 0;
	}

	void Push(int x)
	{
		a[top++] = x;
	}

	int Top()
	{
		return a[top - 1];
	}

	void Destroy()
	{
		free(a);
		a = nullptr;
		top = capacity = 0;
	}

private:
	int* a;
	size_t capacity;
	size_t top;
};

int main()
{
	Stack st;
	st.Init();
	return 0;
}

1.3 类域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员时，需要使用 :: 作用域操作符指明成员属于哪个类域。

class Stack
{
public:
	void Init(int n = 4);


	void Push(int x)
	{
		a[top++] = x;
	}

	int Top()
	{
		return a[top - 1];
	}

	void Destroy()
	{
		free(a);
		a = nullptr;
		top = capacity = 0;
	}

private:
	int* a;
	size_t capacity;
	size_t top;
};

void Stack::Init(int n )
{
	a = (int*)malloc(sizeof(int) * n);
	if (a == nullptr)
	{
		perror("error");
		return;
	}
	capacity = n;
	top = 0;
}

int main()
{
	Stack st;
	st.Init();
	return 0;
}

类域影响的是编译的查找规则，下⾯程序中Init如果不指定类域Stack，那么编译器就把Init当成全局函数，那么编译时，找不到array等成员的声明/定义在哪⾥，就会报错。指定类域Stack，就是知道Init是成员函数，当前域找不到的array等成员，就会到类域中去查找。

二、 实例化

2.1 实例化概念

用类类型创建对象的过程，称为类的实例化

  1. 类是对象进⾏⼀种抽象描述，是⼀个模型⼀样的东西，限定了类有哪些成员变量，这些成员变量只是声明，没有分配空间，⽤类实例化出对象时，才会分配空间。

⼀个类可以实例化出多个对象，**实例化出的对象 占⽤实际的物理空间，存储类成员变量。**打个⽐⽅：类实例化出对象就像现实中使⽤建筑设计图建造出房⼦，类就像是设计图，设计图规划了有多少个房间，房间⼤⼩功能等，但是并没有实体的建筑存在，也不能住⼈，⽤设计图修建出房⼦，房⼦才能住⼈。同样类就像设计图⼀样，不能存储数据，实例化出的对象分配物理内存存储数据。
在这里插入图片描述

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Paint()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	//这里是声明，没有开空间
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date类实例化出对象d1和d2
	
	Date d1;
	d1.Init(2024, 8, 9);
	d1.Paint();

	Date d2;
	d2.Init(2024, 8, 10);
	d2.Paint();
}

在这里插入图片描述

2.2 对象大小

分析⼀下类对象中哪些成员呢？*
类实例化出的每个对象，都有独⽴的数据空间，所以对象中肯定包含成员变量。
那么成员函数是否包含呢？
⾸先函数被编译后是⼀段指令，对象中没办法存储，这些指令存储在⼀个单独的区域(代码段)，那么对象中⾮要存储的话，只能是成员函数的指针。再分析⼀下，对象中是否有存储指针的必要呢，Date实例化d1和d2两个对象，d1和d2都有各⾃独⽴的成员变量_year/_month/_day存储各⾃的数据，但是d1和d2的成员函数Init/Print指针却是⼀样的，存储在对象中就浪费了。如果⽤Date实例化100个对象，那么成员函数指针就重复存储100次，太浪费了。其实函数指针是不需要存储的，函数指针是⼀个地址，调⽤函数被编译成汇编指令[call 地址]，其实编译器在编译链接时，就要找到函数的地址，不是在运⾏时找，只有动态多态是在运⾏时找，就需要存储函数地址。

C++规定类实例化的对象也要符合内存对⻬的规则。

2.3 内存对齐规则

  1. 第⼀个成员在与结构体偏移量为0的地址处。
  2. 其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。
  3. 注意：对⻬数=编译器默认的⼀个对⻬数与该成员⼤⼩的较⼩值。
  4. VS中默认的对⻬数为8
  5. 结构体总⼤⼩为：最⼤对⻬数（所有变量类型最⼤者与默认对⻬参数取最⼩）的整数倍。
  6. 如果嵌套了结构体的情况，嵌套的结构体对⻬到⾃⼰的最⼤对⻬数的整数倍处，结构体的整体⼤⼩
    就是所有最⼤对⻬数（含嵌套结构体的对⻬数）的整数倍。

三、this指针

3.1 this指针的引出

定义一个日期类

class Date
{
public:
	void Init(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Paint()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;
	d1.Init(2024, 8, 9);
	d1.Paint();

	Date d2;
	d2.Init(2024, 8, 10);
	d2.Paint();
}

Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

3.2 this指针的特性

  1. this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
  2. 只能在“成员函数”的内部使用。
  3. this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
  4. this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传
    递，不需要用户传递。
    在这里插入图片描述
class Date
{
public:
	//void Init(Date* const this,int year, int month, int day)
	void Init(int year, int month, int day)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
	void Paint()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1;

	d1.Init(2024, 8, 9);//d1.Init(&d1,2024, 8, 9);
	d1.Paint();

	Date d2;
	d2.Init(2024, 8, 10);//d2.Init(&d2,2024, 8, 10);
	d2.Paint();
}

c++和c语言实现Stack对比

⾯向对象三⼤特性：封装、继承、多态，下⾯的对⽐我们可以初步了解⼀下封装。

  1. C++中数据和函数都放到了类⾥⾯，通过访问限定符进⾏了限制，不能再随意通过对象直接修改数据，这是C++封装的⼀种体现，这个是最重要的变化。这⾥的封装的本质是⼀种更严格规范的管理，避免出现乱访问修改的问题。当然封装不仅仅是这样的，我们后⾯还需要不断的去学习。
  2. C++中有⼀些相对⽅便的语法，⽐如Init给的缺省参数会⽅便很多，成员函数每次不需要传对象地址，因为this指针隐含的传递了，⽅便了很多，使⽤类型不再需要typedef⽤类名就很⽅便。
  3. 在我们这个C++⼊⻔阶段实现的Stack看起来变了很多，但是实质上变化不⼤。

C实现Stack代码

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef int STDataType;
typedef struct Stack
{
    STDataType* a;
    int top;
    int capacity;
}ST;
void STInit(ST* ps)
{
    assert(ps);
    ps->a = NULL;
    ps->top = 0;
    ps->capacity = 0;
}
void STDestroy(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}
void STPush(ST* ps, STDataType x)
{
    assert(ps);
 
        if (ps->top == ps->capacity)
        {
            int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
            STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity *
                sizeof(STDataType));
            if (tmp == NULL)
            {
                perror("realloc fail");
                return;
            }
            ps->a = tmp;
            ps->capacity = newcapacity;
        }
    ps->a[ps->top] = x;
    ps->top++;
}
bool STEmpty(ST* ps)
{
    assert(ps);
    return ps->top == 0;
}
void STPop(ST* ps)
{
    assert(ps);
    assert(!STEmpty(ps));
    ps->top--;
}
STDataType STTop(ST* ps)
{
    assert(ps);
    assert(!STEmpty(ps));
    return ps->a[ps->top - 1];
}
int STSize(ST* ps)
{
    assert(ps);

        return ps->top;
}
int main()
{
    ST s;
    STInit(&s);
    STPush(&s, 1);
    STPush(&s, 2);
    STPush(&s, 3);
    STPush(&s, 4);
    while (!STEmpty(&s))
    {
        printf("%d\n", STTop(&s));
        STPop(&s);
    }
    STDestroy(&s);
    return 0;
}

C++实现Stack代码

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
    //  成员函数
        void Init(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a)
        {
            perror("malloc 申请空间失败");
                return;
        }
        _capacity = n;
        _top = 0;
    }
        void Push(STDataType x)
    {
        if (_top == _capacity)
        {
            int newcapacity = _capacity * 2;
            STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
                sizeof(STDataType));
            if (tmp == NULL)
            {
                perror("realloc fail");
                return;
            }
            _a = tmp;
            _capacity = newcapacity;
        }
        _a[_top++] = x;
    }
    void Pop()
    {
        assert(_top > 0);
        --_top;
    }
    bool Empty()
    {
        return _top == 0;
    }
    int Top()
    {
        assert(_top > 0);
        return _a[_top - 1];
    }
    void Destroy()
    {
        free(_a);
        _a = nullptr;
        _top = _capacity = 0;
    }
private:

        // 成员变量
        STDataType * _a;
    size_t _capacity;
    size_t _top;
};
int main()
{
    Stack s;
    s.Init();
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    while (!s.Empty())
    {
        printf("%d\n", s.Top());
        s.Pop();
    }
    s.Destroy();
    return 0;
}

标签：ps,成员,对象,top,int,Init,void
From： https://blog.csdn.net/GGDxianv/article/details/141063323

相关文章

  • 浅析对象的clone()方法
    ......
  • 一文带您了解如何降低对象存储成本
    本文分享自天翼云开发者社区《一文带您了解如何降低对象存储成本》，作者：刘****筠首先，需要了解天翼云对象存储（原生版）I型ZOS的三种存储类型，分别供标准、低频、归档存储，全面覆盖从热到冷的各种数据存储场景，您可根据使用场景和性能要求选择合适的存储类型。标准存储提供高可靠、高可......
  • Kubernetes对象YAML文件的基本格式详解
    简介  Kubernetes（K8s）作为云原生时代的基础设施核心，其配置文件通常采用YAML格式来定义和管理各种资源对象。YAML（YAMLAin'tMarkupLanguage）因其简洁、易读和易写的特性，在Kubernetes中得到了广泛应用。本文将详细探讨Kubernetes对象YAML文件的基本格式，重点解析GVK（Group、Ve......
  • Kotlin 面向对象编程 (OOP) 基础：类、对象与继承详解
    什么是面向对象编程(OOP)？OOP代表面向对象编程。过程式编程是编写执行数据操作的过程或方法，而面向对象编程则是创建包含数据和方法的对象。与过程式编程相比，面向对象编程具有以下几个优势：OOP更快且更易于执行OOP为程序提供了清晰的结构OOP有助于保持Kotlin代码的DRY......
  • C# & Unity 面向对象补全计划 七大原则 之 合成/聚合复用原则（ CARP）难度：☆☆☆☆ 总结：
    本文仅作学习笔记与交流，不作任何商业用途，作者能力有限，如有不足还请斧正本系列作为七大原则和设计模式的进阶知识，看不懂没关系请看专栏：http://t.csdnimg.cn/mIitr，查漏补缺1.合成/聚合复用原则（CARP）        合成/聚合复用原则就是在一个新的对象里面使用一些已有的......
  • C++——类和对象（全）
    1.类的定义1.1类定义格式classStack{}；1）class为定义类的关键字Stack为类的名字，{}；中为类的主体（分号不能省略）。2）类体中内容称为类的成员：类中的变量称为类的属性或成员变量；类中函数称为类的方法或成员函数；3）为了区分成员变量，一般在成员变量会加上特殊标识_或则m开头。4）C+......
  • java 面向对象2
    1.对类的命名要起到见名知意的效果。对于属性成员最好用private修饰提高权限，使得数据的存储更加安全。一般来说对于类用大驼峰命名法每个单词首字母都是大写如图2.在java中没有指针的概念，但是存在引用所以this在使用的时候就可以通过'.'来访问成员。3.与c++类似不存在空参构造......
  • 轮换挑选图片,补充 es6的对象写法,uniapp使用,class和style,条件渲染,列表渲染,input
    Ⅰ轮换挑选图片【一】方式一<!DOCTYPEhtml><htmllang="en"><head><metacharset="UTF-8"><title>Title</title><scriptsrc="./js2/vue.js"></script></head><body>......
  • [VBA]使用VBA在Excel中 操作 形状shape 对象
            excel已关闭地图插件，对于想做地图可视化的，用形状来操作是一种办法，就是要自行找到合适的地图形状，修改形状颜色等就可以用于可视化展示不同省市销量、人口等数据。引言在Excel中，通过VBA（VisualBasicforApplications）可以极大地增强数据可视化和报告自动化......
  • java进阶面向对象总结二
    1.接口继上次总结，接口是由常量和抽象方法组成，但为了增强接口功能，在jdk1.8之后可以定义含方法体的默认方法，静态方法（版本1.9之后），私有方法，他们分别用defult，static，private修饰2.内部类成员内部类：就是类里面的一个普成员外部类名.内部类名对象名=new外部类().new内部类()；out......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99