c++ 怎样使用类与对象

已于 2024-01-31 21:37:19 修改
阅读量1.1k 收藏 13
点赞数 3
分类专栏： C++ 文章标签： c++ 算法
于 2021-04-05 11:45:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53268869/article/details/115413217
版权

1. 类对象的初始化

1.1 用构造函数实现数据成员的初始化

c++提供构造函数来处理对象的初始化。

构造函数是一种特殊的成员函数，不需要用户来调用它，而是在建立对象时自动执行。

构造函数的名字必须与类名相同。

1.1.1.不带参数的构造函数

又名 默认构造函数

一个类只能有一个默认构造函数，若用户没有定义构造函数，则系统会自动提供一个函数体为空的默认构造函数，不起初始化作用。如果用户希望在创建对象时就能使数据成员有初值，就得自己定义构造函数。

在建立对象的时候执行构造函数，给数据赋初值。如果定义了多个对象，每个对象的数据的初值都是相同的。

补充1：这里需要强调一点，如果我们不写构造函数，则编译器会默认生成构造函数，此时编译器会做一个偏心的处理：内置类型（eg:int,float,douyble…）不会初始化，而自定义类型会调用其无参构造函数，这里算是一个C++的设计缺陷，当然，从C++11开始，在类中定义类成员时可以顺便初始化，算是一定程度上补上了这个缺陷。

补充2:

  • 无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只有一个。
  • 无参构造函数，全缺省构造函数，以及我们没写是编译器自动生成的构造函数，都可以认为是默认构造函数。
public：
	Time()
	{
		hour=0;
		minute=0;
		sec=0;
	}

1.1. 2.带参数的构造函数

用带参的构造函数，可以使同类的不同对象中的数据具有不同的初值

1.在类中定义构造函数
2.在定义对象时指定实参

1.在类中定义构造函数
Box(int h,int w,int len)
{
	height=h;
	width=w;
	length=len;
}

2.在定义对象时指定实参
Box box1(12,25,30);

1.1.3.初始化列表

在构造函数时用参数初始化表实现对数据的赋值

Box(int h,int w,int len):height(h),width(w),lengh(len){}

使用初始化列表是能够提高我们的初始化效率的，原因在于就算我们不显式写出初始化列表，编译器也会自动产生默认初始化列表进行初始化，我们可以认为初始化列表是类内成员的定义位置，默认初始化列表定义但是不初始化。

  1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
  2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
  • 引用成员变量
  • const成员变量
  • 自定义类型成员(该类没有默认构造函数

1.1.4.带默认参数的构造函数

在某些情况下，在定义构造函数时可以加入默认参数，这也叫做缺省参数

Box(int h=10,int w=10,int len=10)
	{
	height=h;
	width=w;
	length=len;
	}

1.1.5 拷贝构造函数

在创建对象时，可否创建一个与一个对象一某一样的新对象呢？
构造函数：只有单个形参，该形参是对本类类型对象的引用(一般常用const修饰)，在用已存在的类类型对象创建新对象时由编译器自动调用。

拷贝构造函数也是特殊的成员函数，其特征如下：

  1. 拷贝构造函数是构造函数的一个重载形式。
  2. 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用
class Date
{
	public:
		Date(int year = 1900, int month = 1, int day = 1)
		{
			_year = year;
			_month = month;
			_day = day;
		}
		//拷贝构造
		Date(const Date& d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
	private:
		int _year;
		int _month;
		int _day;
};
int main()
{
	Date d1;
	Date d2(d1);
	return 0;
}

如果我们不显式定义拷贝构造，则编译器会默认生成拷贝构造，与构造和析构不同的是，这里不会去区分内置类型和自定义类型成员，编译器都会处理。

  1. 内置类型，基于字节序的浅拷贝
  2. 自定义类型，调用其内拷贝构造完成拷贝

那么编译器生成的默认拷贝构造函数已经可以完成字节序的值拷贝了，我们还需要自己实现吗？

我们可以看下面的一段代码：

此时代码会出现崩溃，原因在于默认拷贝使用浅拷贝使得s1._str和 s2._str指向了同一块空间，当s2先析构时，释放此块空间，s1后析构，再次尝试对此块空间析构，造成一块空间的二次释放，显然错误。

因此，在这类场景下，我们需要自己实现深拷贝构造函数。

class String
{
	public:
		String(const char* str = "jack")
		{
			_str = (char*)malloc(strlen(str) + 1);
			strcpy(_str, str);
		}
		~String()
		{
			cout << "~String()" << endl;
			free(_str);
		}
	private:
		char* _str;
};
int main()
{
	String s1("hello");
	String s2(s1);
}

1.2构造函数的重载

使用场景：在一个类中可以定义多个构造函数，供用户选择。

这些构造函数具有相同的名字，但参数的个数或参数的类型不同，这叫做构造函数的重载

#include<iostream>
using namespace std;
class Box
{
public:
	Box() 
	{
		height = 10;
		width = 10;
		lengh = 10;
	};
	Box(int h, int w, int len) :height(h), width(w), lengh(len) {}

	int volume();
private:
	int height;
	int width;
	int lengh;
};

int Box::volume()
{
	return(height * width * lengh);
}

int main()
{
	Box box1,box2(15,30,25);

	cout << "box1 volume:" << box1.volume() << endl;
	cout << "box2 volume:" << box2.volume() << endl;

	return 0;

}

对于上面的程序，值得一提的是，我们建立的两个构造函数同名，那么系统如何辨别调用哪一个函数？是根据函数调用的形式去确定对应哪一个构造函数。

2. 类对象作类成员

应用背景：有时候定义类成员时，可能需要某成员为一个类，方便进行使用

在这里我们以person类为例子，它包含两个类对象，姓名与手机,其中手机包括两个属性：品牌和价格。为了体现明确的逻辑包含关系，我们将手机定义为类对象。

#include<iostream>
#include<string>
using namespace std;

//类对象作为类成员

//手机类
class Phone
{
public:
	Phone(string pName,int pp)
	{
		m_PName = pName;
		Price=pp;
	}

	//手机品牌名称
	string m_PName;
	int Price;
};
//大类
class Person
{
public:
	//Phone m_Phone=pName 隐式转换法
	Person(string name,string pName)
	:m_Name(name),m_Phone(pName){}


	//姓名
	string m_Name;
	//手机
	Phone m_Phone;
};

//当其他类作为本类成员时，构造函数先构造类对象，再构造自身
//析构的顺序与构造相反

void test01()
{
	Person p("Mike","iphone");
	cout << p.m_Name << "拿着" << p.m_Phone.m_PName << endl;
}

int main()
{
	test01();
	return 0;
}

值得注意的是，这个程序有两个类，那么系统先创建了那个类呢？
其实，当其他类作为本类成员时，构造函数先构造类对象，再构造自己，也就是说，先建立了手机类，再建立了大类。
而析构的顺序与构造相反。

3. 静态成员函数

static void func()//书写格式

静态函数的要点：
1.所有对象共享一个函数

2.静态成员函数只能访问静态成员变量
3.静态成员函数也存在访问权限

#include<iostream>
using namespace std;
//静态成员函数
//所有对象共享一个函数
//静态成员函数只能访问静态成员变量
class Person
{
public:
	static void func()
	{
		m_A = 100;//静态成员函数 可以访问 静态成员变量
		~~m_B = 200;~~ //报错，静态成员函数 不可以访问
		// 非静态成员变量，无法区分到底是哪个对象的数据
		cout << "static void func调用" << endl;

		
	}
	
	static int m_A;//静态成员变量
	int m_B;//非静态成员变量

	//静态成员函数也有访问权限
private:
	static void func2()
	{
		cout << "static void func2调用" << endl;
	}
};

int Person::m_A=0;//静态成员变量要在类外声明。

//两种访问方式
void test()
{
	//通过对象访问
	Person p;
	p.func();
	//通过类名创建
	Person::func();
	//Person::func2();//报错，在类外无法访问私有；
}
int main()
{
	return 0;
}

对于静态成员函数，它其实是类的一部分而不是对象的一部分。所以用类或对象都可以创建以及访问。

同时，静态成员n函数也存在着访问权限,它在类外无法访问私有成员

4. 对象指针

1.1指向对象的指针

 书写格式： 类名 * 对象指针名
 
Time *pt;
Time t1;
pt=&t1;

1.2指向对象成员的指针

1.2.1指向对象数据成员的指针

 书写格式： 数据类型名 *指针变量名
 
 int*pi;
 p1=&t1.hour;//将对象t1的数据成员hour的地址赋给p1
 cout<<*p1<<endl;

1.2.2指向对象成员函数的指针

1.指向普通函数的指针变量：
书写格式： 类型名（*指针变量名）（参数表列）

void(*p)();  //p是void型函数的指针变量
p=fun;       //将fun函数的入口地址赋给p,p指向函数fun;
(*p)();      //调用fun函数

2.指向对象成员函数的指针变量：

书写格式：类型名（类名:: *指针变量名）（参数表列）

void (Time:: *p2)();
p2=&Time::get_time;

1.3指向当前对象的this指针

每一个成员函数都包含一个特殊的指针，这个指针的名字是固定的，称为this.它是指向苯类对象的指针，他的值是当前被调用的成员函数所在的对象的起始地址

this指针是隐式使用的,一般不用写。

1.4 空指针访问成员函数

#include<iostream>
using namespace std;

class Person
{
public:
	void showClassName()
	{
		cout << "this is Person class" << endl;
	}
	void showPersonAge()
	{
		cout << "age="<<m_Age << endl;//默认加了this->m_Age,
		//报错原因是传入的指针是为空
	}

	int m_Age;
};

void test01()
{
	Person* p = NULL;
	p->showClassName();
	p->showPersonAge();
}
int main()
{
	void test01();
	return 0;
}

观察该程序，并运行发现报错（部分编译器不会报错），原因在于showPersonName函数。它使用了m_Age这个成员，系统默认在它前面加上了一个this指针，即this->m_Age.
但我们给p指针定义为空，也就是说未创建一个实际存在的对象，this指针找不到类，自然也找不到其中的成员了。

如何解决？

cpp
void showPersonAge()
	{
		if (this == NULL)//加上判空条件
		{
			return;
		}
		cout << "age="<<m_Age << endl;
	}

5. 公用数据的保护

1.1定义常对象

书写格式（两种）：

类名 const 对象名 [ (实参表) ]
const 类名 对象名 [ (实参表) ]

说明：
  1.定义常对象时，必须同时对之进行初始化，之后不可以改变
  2.常对象只能调用它的常成员函数，不能调用该对象的普通成员函数

1.2定义常成员

1.2.1常数据成员

书写格式：

const 类名 成员名

说明：
1.常成员的值不可以改变
2.只能通过构造函数的参数初始化表对常数据成员进行初始化，任何其他函数不能对常数据成员赋值。

1.2.2常成员函数

常函数：

  • 成员函数后 加const后我们称这个函数为常函数
  • 常函数不可以修改成员属性
  • 成员属性声明时加关键字mutable后，在常函数中仍可以修改。

常对象

  • 声明对象前加const称该对象为常对象
  • 常对象只能调用常函数

我们先讲常函数：
书写格式：

void showPerson() const
{
}

在这里,我们要先了解一下this指针的本质，它其实是指针常量，它的指向是不可改变的。可以理解为Personconst this,此时该this指针只能指向Person类，并只能访问Person中的成员，但是要注意成员的值还是可以改变的喔。

倘若还想不让改变值，那么可以理解为const Personconst this,写成程序的话，则应该在成员函数名加const,即void showPerson() const。这里的const实际上修饰的是this 指针，让指针指向的值也变得不可修改

值得一提的是，c++还提供了一种方法，使变量即使在常函数或常对象中也可以修改数值。只要在定义变量时在类型前加关键字mutable。即 mutable int i;

#include<iostream>
using namespace std;

class Person
{
public:

	//this指针的本质：指针常量 指针指向不可修改
	//Person *const this
	//const Person *const this
	void showPerson()const
	{
		//m_Age = 100;//this->m_Age=100;
		this = NULL;
	}
	int m_Age;
};

void test01()
{
	Person p;
	p.showPerson();
}
int main()
{
	void test01();
	return 0;
}

1.3指向对象的常指针

常指针 是 不能改变指向的指针变量
书写格式：

类名 * const 指针变量名

说明：
指向对象的常指针变量的值不能改变，但可以改变其所指对象的值

1.4指向常对象的指针变量

书写格式：

const 类名 * 指针变量名

说明：
1.如果一个变量已经被声明为常变量，只能用指向常变量的指针变量指向它，而不能用一般的指针变量指向它
2.指向常变量的指针变量除了可以指向常变量，还可以指向未被声明为const的变量，此时不能通过指针变量改变该变量的值。

1.5对象的常引用

6. const修饰程序函数

讲完常函数，我们来研究一下常对象

书写方式：

const Person p;

我们都知道常对象中的成员值不可改变，但就像我之前提到的，倘若你在类内定义变量时使用了mutable关键字，那么该变量不论在常函数还是常对象中使用时都可以被改变值。

同时，常对象只能调用常函数。原因通常普通函数函数会修改属性。

7. 友元

  • 全局函数做友元
  • 类做友元
  • 成员做友元

1.全局函数做友元

#include<iostream>
using namespace std;
#include<string>
//建筑物类
class Building
{
//申明为友元函数
	friend void goodGay(Building* building);
public:
	Building()
	{
		m_SittingRoom = "客厅";
		m_BedRoom = "卧室";
	}


	string m_SittingRoom;//客厅
private:
	string m_BedRoom;//卧室
};
void goodGay(Building *building)
{
	cout<<"好基友全局函数 正在访问:"<<building->m_SittingRoom<<endl;

	cout << "好基友全局函数 正在访问:" << building->m_BedRoom<< endl;
}

void tset01()
{
	Building building;
	goodGay(&building);
}
int main()
{
	void test01();
	system("pause");
	return 0;
}

2.类做友元

#include<iostream>
using namespace std;
#include<string>

class Building;

class GoodGay
{
	
public:
	GoodGay();
	void visit();//参观函数，访问Building 中的公共属性
private:	
	Building* building;
};

class Building
{
	**friend class GoodGay;**
public:
	Building();
	string m_SittingRoom;//客厅
private:
	string m_BedRoom;//卧室
};




Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

GoodGay::GoodGay()
{
	building = new Building;
}

void GoodGay::visit()
{
	cout << "好基友全局函数 正在访问:" << building->m_SittingRoom << endl;
	cout << "好基友全局函数 正在访问:" << building->m_BedRoom << endl;
}



void tset01()
{
	GoodGay gg;
	gg.visit();
}
int main()
{
	void test01();
	//system("pause");
	return 0;
}

3.成员函数做友元

#include<iostream>
using namespace std;
#include<string>

class Building;

class GoodGay
{
	
public:
	GoodGay();
	void visit();//参观函数，访问Building 中的公共属性
	void visit2();//让visit2函数不可以访问Building中的私有成员
private:	
	Building* building;
};

class Building
{

	friend void GoodGay::visit();

	
public:
	Building();
	string m_SittingRoom;//客厅
private:
	string m_BedRoom;//卧室
};



//类外实现成员函数
Building::Building()
{
	m_SittingRoom = "客厅";
	m_BedRoom = "卧室";
}

GoodGay::GoodGay()
{
	building = new Building;
}

void GoodGay::visit()
{
	cout << "好基友全局函数 正在访问:" << building->m_SittingRoom << endl;

	cout << "好基友全局函数 正在访问:" << building->m_BedRoom << endl;
}
void GoodGay::visit2()
{
	cout << "好基友全局函数 正在访问:" << building->m_SittingRoom << endl;

	//cout << "好基友全局函数 正在访问:" << building->m_BedRoom << endl;
}



void tset01()
{
	GoodGay gg;
	gg.visit();
	gg.visit2();
}
int main()
{
	void test01();
	//system("pause");
	return 0;
}
Ornamrr
关注
  • 3
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++实验一-类与简单对象.doc
11-15
C++实验一-类与简单对象.doc
c++ 类和对象总结
01-20
话不多说，我们直接进入主题： 对象：客观世界里的一切事物都可以看作是一个对象，每一个对象应当具有属性（静态特征，比如一个班级，一个专业，一个教室）和行为（动态特征，例如：学习，开会，体育比赛等）两个要素。 对象是由一组属性和一组行为构成的。 类（class）：就是对象的类型，代表了某一批对象的共同特性和特征。类是对象的抽象，而对象是类的具体实例。 2.1 类的引入 在C语言中我们定义一个结构体是这样定义的： struct Student { int _age; char* _Gender; char* _Name; }; int main() { struct S; r
C++ 类的使用
qq_53906381的博客
02-23 1092
类定义是以关键字 class 开头，后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。类提供了对象的蓝图，所以基本上，对象是根据类来创建的。声明类的对象，就像声明基本类型的变量一样。
从C到Cpp——五、定义类、类对象和类方法
BUAAer_xuyang的博客
06-27 856
主要介绍了类的定义和使用方法
c++类的定义与使用
bhbca的博客
02-11 6629
c++类的定义和使用
C++类的使用
孤旅人。。。的博客
08-22 629
（一）类的封装 1）封装（Encapsulation） A）封装，是面向对象程序设计最基本的特性。把数据（属性）和函数（操作）合成一个整体，这在计算机世界中是用类与对象实现的。 B）封装，把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行信息隐藏。C++中类的封装 成员变量，C++中用于表示类属性的变量 成员函数，C++中用于表示类行为的函数2）
c++学习笔记...对象的使用
whereismusi的博客
12-04 250
自己写点笔记听得入脑
【C++】类和对象---需掌握的功能
m0_52094687的博客
02-12 994
该博客介绍了C++中初始化列表的概念和如何使用，讲了explicit关键字在什么情况下使用、static成员的用法，匿名对象如何创建、友元函数和友元类各有什么功能、内部类是什么、拷贝对象时编译器会做的一些优化、最后介绍了面向对象的概念
c++对象详解
Yoyo的博客
08-16 1513
C++中的对象是面向对象编程的核心概念，它将数据和方法组合在一起，实现高度模块化、可重用、可扩展的代码结构。本文详细介绍了C++对象的概念、特性与行为、创建和使用方法，以及对象间的交互。本文将详细介绍C++中的对象概念、对象的特性与行为、对象的创建和使用、以及对象间的交互，并提供多个具体示例代码以帮助读者深入理解对象的使用和设计。对象是类的实例化，它是具体的、有形的实体。数据成员存储对象的属性和信息，可以被对象的成员函数访问和操作。成员函数可以是公有的、私有的或受保护的，用于控制对数据成员的访问权限。
C++类与对象
12-03
C++类与对象 C++ 中的类是一种框架，并不代表真正的实体，是由用户根据具体问题抽象出共同的属性和行为后自己定义的一种类型。类的实体叫做实例，又叫做对象，在前几章也叫变量。任何一个汽车都是属于汽车类中的一...
C++ 类与对象习题
10-14
C++ 类与对象习题，都是入门知识，给初学者参考^-^
C++ 类和对象基础篇
08-25
"C++ 类和对象基础篇" 本节课程主要讲解了 C++ 中的类和对象基础知识。...本节课程详细讲解了 C++ 中的类和对象基础知识，包括类的定义、创建对象并访问类的成员、使用对象指针等内容，为后续学习提供了坚实的基础。
c++基本使用（类）
记录我目之所及的世界
03-06 235
class类
C++面向对象（一）定义类、创建对象、使用
锅锅的博客
12-10 883
c++相对c最特别的增加了面向对象的编程，一方面自身可以去设计一些对象，自己使用或者交给他人使用，另一方面官方也提供了很多对象可以直接继承过来自己使用，达到快速开发项目。
C++ 类和对象的使用
PFzcnds8310__的博客
03-20 745
类和对象的使用 1.对象的初始化——构造函数 在对类对象的数据进行赋值时，可以在类中直接赋值，但不推荐，因为类不是实体，是抽象的概念，不占用存储空间。 class Student { public: string addr = "北京市朝阳区"; void display(); private: int num = 0; string name = "Tom"; ...
C++类和对象（一）
热门推荐
ll1175555的博客
07-13 1万+
目录面向过程和面向对象初步认识类的定义类的作用域类的实例化类的访问限定符及封装类的对象大小计算类成员函数this指针 面向过程和面向对象初步认识 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 比如一个外卖系统 面向过程：下单、接单、送餐三个过程 面向对象：客户、商家、骑手，关注的是三个类对象之间的关系 类的定义 class Name { //类体:由成员函数和成员变量组成
C++可调用对象
qq_43148810的博客
04-15 895
可调用对象 接受或者可调用对象的封装 bind、function、packaged_task
C的I/O操作
最新发布
weidl001的博客
06-17 740
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
c++类与对象
05-30
在C++中，使用类和对象可以实现面向对象编程的思想，使程序更加模块化、可维护和易扩展。 下面是一个简单的C++类的示例： ```c++ class Person { private: string name; int age; public: void setName...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ornamrr

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值