【C++】类和对象

weixin_45766539

已于 2024-06-29 11:58:15 修改

阅读量495

点赞数 20

分类专栏： C++ 文章标签： c++

于 2024-06-21 23:06:57 首次发布

本文链接：https://blog.csdn.net/weixin_45766539/article/details/139829693

版权

C++ 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

一、类的定义

class 类名
{
//访问修饰符：//public或protected或private
//成员变量和成员方法
};

二、访问权限：

public，公有，类内类外均可访问，可继承

protected，保护，类内可访问，类外不可访问，可继承。

private，私有，类内可访问，类外不可访问，不可继承。（实际上子类的对象仍会开辟父类私有成员变量的内存，但被隐藏了，不可访问操作）

与struct不同，若不声明权限，类中成员默认为私有private成员。

三、构造函数和析构函数

（若未提供构造和析构，编译器会提供编译器提供的构造函数和析构函数，是空实现）

构造函数：主要作用在于创建对象时为对象的成员属性赋值

构造函数与析构函数语法：

构造函数语法：类名(){}

1.构造函数，没有返回值也不写void
2.函数名称与类名相同
3.构造函数可以有参数，因此可以发生重载
4.程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

按参数分为:有参构造和无参构造
按类型分为:普通构造和拷贝构造

拷贝构造函数的参数一定要是：const 类名 &对象名。比如：Person（const Person &p1）

析构函数语法：~类名(){}

1.析构函数，没有返回值也不写void
2.函数名称与类名相同,在名称前加上符号~
3.析构函数不可以有参数，因此不可以发生重载
4.程序在对象销毁前会自动调用析构，无须手动调用，而且只会调用一次

调用：

（匿名对象特点:当前行执行结束后，系统会立即回收掉匿名对象）

注意1：调用默认构造函数的时候不要加()，否则编译器会认为是一个函数的声明Person pl();

注意2：不要利用拷贝构造函数初始化匿名对象编译器会认为Person(p3) == = Person p3; 对象声明

class Person
{
public:
	Person()
	{
		cout << "默认构造函数调用" << endl;
	}
	Person(int a)
	{
		cout << "有参构造函数调用" << endl;
	}
	Person(const Person &p)
	{
		cout << "拷贝构造函数调用" << endl;
	}
	int a;

};
void test()
{
	//1、括号法
	Person pl;			//默认构造函数调用
	Person p2(10);		//有参构造函数
	Person p3(p2);		//拷贝构造函数
	//注意1：调用默认构造函数的时候不要加()，
    //否则编译器会认为是一个函数的声明Person pl()

	//2、显示法
	Person pl;
	Person p2 = Person(10);			//有参构造
	Person p3 = Person(p2);			//拷贝构造
	//Person(10);  //匿名对象 特点:当前行执行结束后，系统会立即回收掉匿名对象
	//注意2：不要利用拷贝构造函数 初始化匿名对象 
    //编译器会认为Person(p3) == = Person p3; 对象声明

	//3、隐式转换法
	Person p4 = 10;		//相当于写了Person p4=Person(10); 有参构造
	Person p5 = p4;		//拷贝构造
}
int main()
{
	test();
	return 0;
 }

拷贝构造函数的调用时机

1、使用一个已经创建完毕的对象来初始化一个新对象

2、值传递的方式给函数参数传值

3、值方式返回局部对象

class Person
{
public:
	Person()
	{
		cout << "默认构造函数调用" << endl;
	}
	Person(int a)
	{
		cout << "有参构造函数调用" << endl;
	}
	Person(const Person &p)
	{
		cout << "拷贝构造函数调用" << endl;
	}
	int a;

};
void test1()
{

	//1、使用一个已经创建完毕的对象来初始化一个新对象
	Person p1(20);
	Person p2(p1);
}
	//2、值传递的方式给函数参数传值
void doWork1(Person p)
{

}
void test2()
{
		Person p1;
		doWork1(p1);
}
	//3、值方式返回局部对象
Person doWork2()
{
	Person p;
	return p;
}
void test3()
{
	doWork2();
}
int main()
{
	test1();
	test2();
	test3();
	return 0;
 }

调用规则：

默认情况下，C++编译留至少给一个类添加3个函数
1.默认构造函数(无参，函数体为空)
2.默认析构函数(无参，函数体为空)
3.默认拷贝构造函数，对属性进行值拷贝
构造函数调用规则如下:
如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造。如果用户定义拷贝构造函数，c++不会再提供其他构造函数

深拷贝与浅拷贝：

浅拷贝：简单的赋值拷贝操作
深拷贝：在堆区重新申请空间，进行拷贝操作

class Person
{
public:
	Person(int Height)
	{
		cout << "有参构造函数调用" << endl;
		m_Heigh = new int(Height);
	}
	Person(const Person &p)
	{
		this->m_Heigh = new int(*p.m_Heigh);	
    //深拷贝，重新申请内存空间，避免释放的时候重复释放，报错
	//浅拷贝，编译器默认的拷贝函数执行简单的赋值操作this->m_Heigh = p.m_Heigh;
	}
	~Person()
	{
		if (m_Heigh != NULL)
		{
			delete m_Heigh;
			m_Heigh = NULL;
		}
	}
private:
	int *m_Heigh;
};
void test()
{
	Person p1(175);
	Person p2(p1);
}
int main()
{
	test();

	return 0;
 }

初始化列表：

语法:构造的数():属性1(值1),属性2(值2)...{}

class Phone
{
public:
	Phone()
	{
		cout << "Phone 默认构造函数调用" << endl;
	}
	Phone(string pName)
	{
		cout << "Phone有参构造函数调用" << endl;
		m_pName = pName;
	}
	~Phone()
	{
		cout << "Phone析构函数调用" << endl;
	}
private:
	string m_pName;
};
class Person
{
public:
	Person(string pName):m_Phone(pName)	
    //相当于Phone m_Phone=pName;且不需要调用Phone默认构造函数
	{
		cout << "Person构造函数调用" << endl;
	}
	~Person()
	{
		cout << "Person析构函数调用" << endl;
	}
private:
	Phone m_Phone;
};
void test()
{
	Person p("IPhoneX");
}
int main()
{
	test();
	return 0;
 }

四、对象作为类成员：

当类中成员是其他类对象时，我们称该成员为对象成员

构造的顺序是:先调用对象成员的构造，再调用本类构适

析构顺序与构造相反

析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

五、静态成员：

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员静志成员分为：
（1）静态成员变量
所有对象共享同一份数据
在编译阶段分配内存
类内声明，类外初始化
（2）静志成员函数
所有对象共享同一个函数
静态成员函数只能访问静态成员变量
（3）静态成员的2种访问方式：
a, 通过对象访问。b, 通过类名进行访问（注意：静态成员变量也有访问权限，私有权限类外无法访问）

class Person
{
public:
	static int m_A;
};
int Person:: m_A= 20;		//初始化类的静态成员变量
void test()
{
	//1、通过对象访问
	Person p;
	cout << p.m_A << endl;
	//2、通过类名访问
	cout << Person::m_A << endl;
}
int main()
{
	test();
	return 0;
 }

六、内存模型：

空对象占用1个字节空间，是为了区分空对象占内存位置。

非静态成员变量属于类的对象上

静态成员变量不属于类对象上

非静态成员函数不属于类对象上

静态成员函数不属于类的对象上

七、this指针：

（this指针的本质是个指针常量，指向不可修改）

this指针的用途：
当形参和成员变量同名时，可用this指针来区分
在类的非静态成员函数中返回对象本身，可使用return *this

class Person
{
public:
	Person &add(Person &p)		//引用，输出结果为80   80
	//Person add(Person &p)		//赋值一个新对象，输出结果为60   20
	{
		this->m_A += p.m_A;
		return *this;
	}
	int m_A;
};

void test()
{
	Person p1;
	p1.m_A = 10;

	cout<<p1.add(p1).add(p1).add(p1).m_A<<endl;
	cout << p1.m_A;
}
int main()
{
	test();
	return 0;
 }

八、空指针访问成员函数

C++中空指针也是可以调用成员的数的，但是也要注意有没有用到this指针，
如果用到this指针，需要加以判断保证代码的健壮性。

如加入：if(this==NULL){return;}

九、const修饰成员函数

常函数：

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

public:
	//this指针的本质 是指针常量，指针的指向是不可以修改的Person *const this;
	//在成员函数后面加const，修饰的是this指向，
    //相当于const Person *const this;，让指针指向的值也不可以修改
	void showPerson() const
	{
		this->m_A = 10;
	}
	mutable int m_A;		//加上mutable，变成特殊变量，
                            //即使在常函数中，也可以修改这个值
};

this指针的本质是指针常量，指针的指向是不可以修改的Person *const this;
在成员函数后面加const，修饰的是this指向，
相当于const Person *const this; 让指针指向的值也不可以修改

常对象：

声明对象前加const称该对象为常对象
常对象只能调用常函数(或调用mutable修饰的特殊变量)