【C++】类和对象（一）

爱编程的小马.

于 2024-07-31 21:33:00 发布

阅读量555

点赞数 20

分类专栏： C++ 文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/s1mplewo/article/details/140832215

版权

C++ 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

前言

📚作者简介：爱编程的小马，是一名大厂后端c++程序员。

📚本文收录于C++系列，本专栏主要是分享我所了解的c++知识，带领大家慢慢从了解c++到认识c++，持续更新！

📚相关专栏Linux正在发展，敬请期待！

📚本文主要内容：简单介绍C++类和对象

1.类的引入

1.1 什么是类

和C++类似，在C语言中，结构体只能定义变量，不能定义函数。在C++中，类既可以定义变量，也可以定义函数。用C语言实现的顺序表，只能定义变量，而用C++实现的顺序表，则可以在类中定义函数。

#include<iostream>
using namespace std;

typedef int SeqListDataType;

struct SeqList
{
	void Init()
	{
		SeqListDataType* tmp = (SeqListDataType*)malloc(sizeof(SeqListDataType) * 4);
		if (tmp == nullptr)
		{
			perror("malloc failed");
			return;
		}
		a = tmp;
		size = 0;
		capacity = 4;
	}
	void Push(int x)
	{
		if (size == capacity)
		{
			SeqListDataType* tmp = (SeqListDataType*)realloc(a,sizeof(SeqListDataType) * capacity*2);
			if (tmp == nullptr)
			{
				perror("malloc failed");
				return;
			}
			capacity *= 2;
		}
		a[size++] = x;
	}
	void Destory(int x)
	{
		free(a);
		a = nullptr;
		size = capacity = 0;
	}
	int operator[](int i)
	{
		return a[i];
	}


	SeqListDataType* a;
	int size;
	int capacity;
};

int main()
{
	SeqList s1;
	s1.Init();
	s1.Push(1);
	s1.Push(2);
	s1.Push(3);
	s1.Push(4);
	s1.Push(5);
	s1.Push(6);
	s1.Push(7);
	for (int i = 0; i < s1.size; i++)
	{
		cout << s1[i] << " ";
	}
	return 0;
}

1.2 类的定义


class classname
{
	//类体：由成员函数和成员变量构成
};

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号不能省略。

类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

类的定义方式

1、声明和定义全部放在类体中，需注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。

2、声明和定义分离，注意在使用时需要加上域作用限定符

2.封装

2.1 类的访问限定符

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

有三种，第一个是公有public，第二个是私有private，第三个是保护protected

性质：

1、public可以在类外面直接访问

2、private和protected不能在类外面直接被访问

3、访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

2.2 封装

封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

2.3 类的作用域

类定义了一个新的类域，类的所有成员都在类域中。在类外定义成员是，需要使用域作用限定符来指明函数属于哪个类域的，例如以下例子

class Person
{
public:
	Person()
		:_name("张三")
		,_age(18)
		,_number("123456")
	{}
	void Print();
private:
	char _name[20];
	int _age;
	char _number[20];
};

//声明和定义分离，需要加域作用限定符
void Person::Print()
{
	cout << "名字:" << _name << " " << "年龄:" << _age << " " << "学号:" << _number << " ";
}
int main()
{
	Person a;
	a.Print();
	return 0;
}

2.4.类的实例化

用类类型创建对象的过程，称为类的实例化；类是对对象进行描述的，是一个模型一样的东西，限定了类有哪些成员，定义出一个类并没有分配实际的内存空间来存储它；一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

3.this指针

我们先一起完成一个简单的日期类

class Date
{
public:
	Date(int year=1, int month=1 ,int day=1)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
	void Print();
private:
	int _year;
	int _month;
	int _day;
};
void Date::Print()
{
	cout << _year << "/" << _month << "/" << _day << endl;
}
int main()
{
	Date d1(2024, 7, 31);
	Date d2(2000, 07, 24);
	Date d3;
	d1.Print();
	d2.Print();
	d3.Print();
	return 0;
}

对于上述类，有这样的一个问题： Date类中有 Print 成员函数，函数体中没有关于不同对象的区分，那当d1调用函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？

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

那么上述代码也可以这么写，但是没必要，显得很奇怪。

class Date
{
public:
	
	Date(int year = 1, int month = 1, int day = 1)
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
	}
	void Print();
private:
	int _year;
	int _month;
	int _day;
};
void Date::Print()
{
	cout << this->_year << "/" << this->_month << "/" << this->_day << endl;
}
int main()
{
	Date d1(2024, 7, 31);
	Date d2(2000, 07, 24);
	Date d3;
	d1.Print();
	d2.Print();
	d3.Print();
	return 0;
}