[c++学习笔记07]：类和对象——对象特性

最新推荐文章于 2023-02-24 14:47:04 发布
最新推荐文章于 2023-02-24 14:47:04 发布
阅读量281 收藏
点赞数
分类专栏： c++ 文章标签： c++ 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dinnersize/article/details/105717168
版权

一.构造函数和析构函数
“恢复出厂设置”
构造函数：初始化
析构函数：清理
如果没有定义的话，编译器自动给你弄，但是是空函数。

//1.1构造函数
//没有返回值，不用写void
//函数名与类名相同
//构造函数可以有参数，可以发生重载
//创建对象的时候，构造函数会自动调用，且只调用一次

//1.2析构函数（进行清理的操作）
//没有返回值，不用写void
//函数名：  ~类名
//析构函数不可以有参数，不可以发生重载
//对象在销毁时，可以自动调用构造函数，且只调用一次

#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
class Person
{
public:
	//1.1构造函数
	//没有返回值，不用写void
	//函数名与类名相同
	//构造函数可以有参数，可以发生重载
	//创建对象的时候，构造函数会自动调用，且只调用一次
	Person()
	{
		cout << "构造函数的调用" << endl;
	}
	//1.2析构函数（进行清理的操作）
	//没有返回值，不用写void
	//函数名：  ~类名
	//析构函数不可以有参数，不可以发生重载
	//对象在销毁时，可以自动调用构造函数，且只调用一次
	~Person()
	{
		cout << "析构函数的调用" << endl;
	}
};
void test()
{
	Person p;
}
int main()
{
	//test();
	Person p;
	system("pause");
	return 0;
}

————————————————————————
二.构造函数的分类及调用。
//1.构造函数的分类及调用
//分类
//按照参数分类： 有参构造 （默认构造）和 无参构造
//按照类型分类： 普通构造 和 拷贝构造

//1.括号法 简单好用，推荐！
Person p1;//默认构造函数调用
Person P2(10);//有参构造函数调用
Person P3(P2);//拷贝构造函数的调用
//注意事项1：
//调用默认构造函数时候，不加()
//Person p1();编译器会认为是一个函数的声明，不会认为在创建对象
//void p1(); 【类似】
cout << “P2的年龄是” << P2.age << endl;
cout << “P3的年龄是” << P3.age << endl;

//2.显示法
Person P1;//无参调用
Person P2 = Person(10);//有参调用
Person P3 = Person(P2);//拷贝构造
Person(10);// 匿名对象  特点：当前行执行结束后，系统直接立即收回匿名对象
cout << "aa";
//注意事项2：
//不要利用拷贝构造函数  初始化匿名对象
//Person(P3);//编译器认为：Person(P3)==Person P3; 对象的声明

//3.隐式构造法
Person P4 = 10;//等价为  Person P4 = Person(10);
Person P5 = P4;//拷贝构造

#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//1.构造函数的分类及调用
//分类
//按照参数分类：  有参构造 （默认构造）和   无参构造
//按照类型分类：  普通构造             和   拷贝构造
class Person
{
public:

	//构造函数
	Person()//无参  （普通）
	{
		cout << "无参构造函数的调用" << endl;
	}
	Person(int a)//有参  （普通）
	{
		age = a;
		cout << "有参构造函数的调用" << endl;
	}
	//拷贝构造函数
	Person(const Person& p)//有参（拷贝）
	{
		//将传入的人身上的所有属性拷贝到我身上
		age = p.age;
		cout << "拷贝构造函数的调用" << endl;
	}
	~Person()
	{
		cout << "析构函数的调用" << endl;
	}
	int age;
};
void test()//构造函数调用
{
	//1.括号法  简单好用，推荐！
	Person p1;//默认构造函数调用
	Person P2(10);//有参构造函数调用
	Person P3(P2);//拷贝构造函数的调用
	//注意事项1：
	//调用默认构造函数时候，不加()
	//Person p1();编译器会认为是一个函数的声明，不会认为在创建对象
	//void p1();  【类似】
	cout << "P2的年龄是" << P2.age << endl;
	cout << "P3的年龄是" << P3.age << endl;

	//2.显示法
	Person P1;//无参调用
	Person P2 = Person(10);//有参调用
	Person P3 = Person(P2);//拷贝构造
	Person(10);// 匿名对象  特点：当前行执行结束后，系统直接立即收回匿名对象
	cout << "aa";
	//注意事项2：
	//不要利用拷贝构造函数  初始化匿名对象
	//Person(P3);//编译器认为：Person(P3)==Person P3; 对象的声明
	
	//3.隐式构造法
	Person P4 = 10;//等价为  Person P4 = Person(10);
	Person P5 = P4;//拷贝构造

}
int main()
{
	test();

	system("pause");
	return 0;
}

—————————————————————————

三.拷贝构造函数的调用时机：
1.使用一个已经创建完毕的对象初始化一个新对象
2.值传递的方式给函数参数传值
3.值方式返回局部变量

#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。

class Person
{
public:

	//构造函数
	Person()//无参  （普通）
	{
		cout << "无参构造函数的调用" << endl;
	}
	Person(int a)//有参  （普通）
	{
		age = a;
		cout << "有参构造函数的调用" << endl;
	}
	//拷贝构造函数
	Person(const Person& p)//有参（拷贝）
	{
		//将传入的人身上的所有属性拷贝到我身上
		age = p.age;
		cout << "拷贝构造函数的调用" << endl;
	}
	~Person()
	{
		cout << "析构函数的调用" << endl;
	}
	int age;
};
//1.使用一个已经创建完毕的对象初始化一个新对象
void test01()
{
	Person p1(10);
	Person p3(p1);
	cout << "p3的年龄" << p3.age << endl;
}
void dowork(Person p)
{

}
//2.值传递的方式给函数参数传值
void test02()
{
	Person p;
	dowork(p);//拷贝一个副本过来，两个p不是一回事。
}
Person dowork2()
{
	Person p;
	cout << (int*)&p << endl;//两个p不是一回事。
	return p;
}
//3.值方式返回局部变量
void test03()
{
	Person p = dowork2();
	cout << (int*) &p << endl;//两个p不是一回事。
}
int main()
{
	//test01();
	//test02();
	test03();
	
	system("pause");
	return 0;
}

————————————————————————
四.构造函数的调用规则
//1.默认情况下，创建一个类，c++编译器至少给一个类添加至少3个函数
//默认构造 （空实现）
//析构函数 （空实现）
//拷贝构造 （值拷贝*）*

//2.如果我们写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造
//如果我们写了拷贝构造函数，编译器就不再提供其他构造了

#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//构造函数的调用规则
//1.默认情况下，创建一个类，c++编译器至少给一个类添加至少3个函数
//默认构造 （空实现）
//析构函数 （空实现）
//拷贝构造 （值拷贝）

//2.如果我们写了有参构造函数，编译器就不再提供默认构造，依然提供拷贝构造
//如果我们写了拷贝构造函数，编译器就不再提供其他构造了


class Person
{
public:

	//构造函数
	//Person()//无参  （普通）
	//{
	//	cout << "无参构造函数的调用" << endl;
	//}
	//Person(int a)//有参  （普通）
	//{
	//	age = a;
	//	cout << "有参构造函数的调用" << endl;
	//}
	//拷贝构造函数
	Person(const Person& p)//有参（拷贝）
	{
		//将传入的人身上的所有属性拷贝到我身上
		age = p.age;  // 虽然没写被注释掉了，但是默认有他的
		cout << "拷贝构造函数的调用" << endl;
	}
	~Person()
	{
		cout << "析构函数的调用" << endl;
	}
	int age;
};

//void test01()
//{
//	Person p1;
//	p1.age = 10;
//	Person p3(p1);
//	cout << "p3的年龄" << p3.age << endl;
//}
void test02()
{
	Person p(1);
	Person p2(p);
	cout << "p2的年龄" << p2.age << endl;
}

int main()
{
	//test01();
	test02();
	//test01();
	
	system("pause");
	return 0;
}

逻辑如图：
在这里插入图片描述

————————————————————————
五.浅拷贝与深拷贝
浅拷贝：简单的赋值操作，没有写拷贝函数时候会浅拷贝
深拷贝：自己new一个堆区空间，进行拷贝。
简言之： new 了就得 写拷贝构造函数。（深拷贝）
//析构函数，将堆区开辟的数据释放的操作

~Person()
	{
		//析构函数，将堆区开辟的数据释放的操作
		if (m_Height == NULL)
		{
			delete m_Height;
			m_Height = NULL;//防止野指针
		}
		cout << "析构函数的调用" << endl;
	}

“奇怪的是我实操时候没有进行深拷贝也没有报错，为了严谨起来以后就这样规范写”
如下。

#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//深拷贝和浅拷贝
class Person
{
public:

	Person()//
	{
		cout << "无参构造函数的调用" << endl;
	}
	Person(int a,int Height)
	{
		age = a;
		m_Height = new int(Height);//指针接收堆区的数据
		cout << "有参构造函数的调用" << endl;
	}
	//自己构造拷贝构造函数，解决浅拷贝带来的问题
	Person(const Person& p)//有参（拷贝）
	{
		//m_Height = p.m_Height; 编译器的拷贝操作，会在释放堆区的时候出错。
		age = p.age;  
		//深拷贝操作
		m_Height = new int(*p.m_Height);
		cout << "拷贝构造函数的调用" << endl;
		
	}
	~Person()
	{
		//析构函数，将堆区开辟的数据释放的操作
		if (m_Height == NULL)
		{
			delete m_Height;
			m_Height = NULL;//防止野指针
		}
		cout << "析构函数的调用" << endl;
	}
	int age;
	int* m_Height;//身高
};
void test01()
{
	Person p1(18,160);
	cout << "p1" << p1.age <<"shengao" <<p1.m_Height<<endl;
	Person p2(p1);
	cout << "p2" << p2.age << "shengao" << p2.m_Height << endl;
}

int main()
{
	test01();
	//test02();
	//test01();
	
	system("pause");
	return 0;
}

如果属性有堆区的数据，一定要构造拷贝函数，进行深拷贝，防止浅拷贝带来的 “重复释放堆区”的问题。
逻辑图：
在这里插入图片描述
六、初始化列表
相对传统初始化方式简单，代码短，加“：”
代码如下：

#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//初始化列表
class Person
{
public:
	//传统初始化操作
	//Person(int a,int b,int c)
	//{
	//	m_a = a;
	//	m_b = b;
	//	m_c = c;
	//}

	//初始化列表初始化属性
	Person(int a, int b, int c) :m_a(a), m_b(b), m_c(c)
	{

	}
	int m_a;
	int m_b;
	int m_c;
};
void test01()
{
	//传统初始化操作
	//Person p(18,2,160);

	//初始化列表初始化属性
	Person p(1, 2, 160);
	cout << "a " << p.m_a <<"b " <<p.m_b<<"c "<<p.m_c<<endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

七、类对象作为类成员
//其他类作为本类成员时，构造函数时候先构造类对象，再构造自身，析构函数的顺序相反。
格式：


class A{};
class B
{
	A a;
};

#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。

class Phone
{
public:
	Phone(string Pname)
	{
		m_Pname = Pname;
		cout << "手机类构造出函数的调用" << endl;
	}
	~Phone()
	{
		cout << "手机类析构函数的调用" << endl;
	}
	string m_Pname;
};
class Person
{
public:
	
	Person(string a, string b) :m_name(a), m_phone(b)//等价为Phone m_phone = b （隐式构造）
	{
		cout << "人类构造函数的调用" << endl;
	}
	~Person()
	{
		cout << "人类析构函数的调用" << endl;
	}
	string m_name;
	Phone m_phone;
	
};
//其他类作为本类成员时，构造时候先构造类对象，再构造自身，析构函数的顺序相反。
void test01()
{
	Person p("张故", "华为");
	cout << p.m_name << "有" << p.m_phone.m_Pname << endl;
}

int main()
{
	test01();
	system("pause");
	return 0;
}

八、静态成员
（一）、静态成员变量
//1.所有对象共享同一份数据，同时被改变
//2.在编译阶段分配内存
//3.类内声明，类外初始化
//4.静态成员变量也有访问权限

//因此有两种访问方式

//1.通过对象访问
Person p;
cout << p.m_A << endl;

//2.通过类名访问
cout << Person::m_A << endl;

#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//静态成员变量
class Person
{
public:
	//1.所有对象共享同一份数据
	//2.在编译阶段分配内存
	//3.类内声明，类外初始化
	static int m_A; //类内声明
	
	//静态成员变量也有访问权限
private:
	static int m_B;
};
int Person::m_A = 10;//类外初始化
int Person::m_B = 130;
void test01()
{
	//静态成员变量  不属于某个对象，所有对象共享一份数据

	Person p1;
	cout << p1.m_A << endl;
	Person p2;
	p2.m_A = 112;
	cout << p1.m_A << endl;//共享数据，同被改变
}
void test02()
{
	//因此有两种访问方式

	//1.通过对象访问
	Person p;
	cout << p.m_A << endl;

	//2.通过类名访问
	cout << Person::m_A << endl;

	cout << Person::m_B << endl;//此处不可访问，证明有权限
}
int main()
{
	test01();
	test02();
	system("pause");
	return 0;
}

（二）、静态成员函数
//1.所有对象共享一个函数
//2.静态成员函数只能访问静态成员变量
//静态成员函数也有访问权限

//有两种访问方式

//1.通过对象访问
Person p;
p.func();

//2.通过类名访问
Person::func();
//Person::func2();类外访问不到私有静态成员函数。

#include<iostream>
using namespace std;
#include<string>
#include<Math.h>
#include <cstdlib>//解决system不明确问题。
//静态成员变量
class Person
{
	//1.所有对象共享一个函数
	//2.静态成员函数只能访问静态成员变量
public:
	static void func()
	{
		m_A = 1;//静态成员函数  可以  访问静态成员变量
		//m_B = 2;//静态成员函数  不可以  访问非静态成员变量，因为不能区分到底是哪个对象的m_B属性
		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 = 10;//类外初始化


void test02()
{
	//有两种访问方式

	//1.通过对象访问
	Person p;
	p.func();

	//2.通过类名访问
	Person::func();
	//Person::func2();类外访问不到私有静态成员函数。
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

九、c++对象模型和this指针
c++对象模型：
成员函数和成员变量分开存储，只有非静态变量才属于类的对象上。
注意：

class Person
{
	int m_A;//非静态成员变量,   属于类的对象上  Only one
	static int m_B;//静态成员变量，  不属于类的对象上
	void func(){}   //非静态成员函数，  不属于类的对象上
	static void func1(){}//静态成员函数， 不属于类的对象上
};

//空对象占用的内存为 1 
//C++编译器会给每个空对象也分配一个字节的空间，是为了区分空对象占内存的位置。
//每个空对象也应该有一个有一个独一无二的内存地址。

#include<iostream>
using namespace std;
#include<string>
//成员变量和成员函数分开存储
class Person
{
	int m_A;//非静态成员变量,   属于类的对象上  Only one
	static int m_B;//静态成员变量，  不属于类的对象上
	void func(){}   //非静态成员函数，  不属于类的对象上
	static void func1(){}//静态成员函数， 不属于类的对象上
};
int Person::m_B = 10;//类外初始化


void test02()
{
	Person p;
	//空对象占用的内存为 1 
	//C++编译器会给每个空对象也分配一个字节的空间，是为了区分空对象占内存的位置。
	//每个空对象也应该有一个有一个独一无二的内存地址。
	cout << sizeof(p) << endl;
}
void test01()
{
	Person p;
	cout << sizeof(p) << endl;
}
int main()
{
	test01();
	//test02();
	system("pause");
	return 0;
}

this指针
//this指针概念
//每个非静态成员函数只会生成一份函数实例，即多个同类型的对象会共用一块代码
//this指针可以解决！ this指针指向 被调用的成员函数 所属的对象
//this指针 是隐含 每一个非静态成员函数 内的一种指针

//this指针的俩用途
//1、解决名称冲突。
//2.返回对象本身用 *this

#include<iostream>
using namespace std;
#include<string>
//this指针概念
//每个非静态成员函数只会生成一份函数实例，即多个同类型的对象会共用一块代码
//this指针可以解决！      this指针指向  被调用的成员函数   所属的对象
//this指针      是隐含   每一个非静态成员函数   内的一种指针
class Person
{
public:
	Person(int age)
	{
		//this指针指向  被调用的成员函数   所属的对象
		this->age = age;//解决名称冲突。
	}
	Person& Personageadd(Person& p)//如果不是不返回引用，以值的方式返回，那么每次都会copy一个P，于是只加了一次，返回的是20
	{
		this->age += p.age;
		return *this;//返回对象本身用*this
	}
	int age;
};

//this指针的俩用途
//1、解决名称冲突。
void test01()
{
	Person p1(18);
	cout << "p1的年龄：" << p1.age << endl;
}

//2.返回对象本身用*this
void test02()
{
	Person p1(10);
	Person p2(10);
	//链式编程思想
	p2.Personageadd(p1).Personageadd(p1).Personageadd(p1);
	cout << "p2的年龄：" << p2.age << endl;
}
int main()
{
	//test01();
	test02();
	system("pause");
	return 0;
}

十、空指针访问成员函数

空指针也可以调用成员函数，但是需要考虑有没有调用this指针*（空指针无法调用this指针）
如果有，就需要修改代码，以保证代码的健壮性*

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

//空指针调用成员函数

class Person
{
public:
	void showClassName()
	{
		cout << "这是人类" << endl;
	}
	void showPersonAge()
	{
		//报错原因是传入的指针是NULL
		if (this == NULL)
		{
			return;
		}
		cout << "age" << this->m_age << endl; //m_age默认加了个this->m_age
	}
	int m_age;
};

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

void test02()
{

}
int main()
{
	test01();
	//test02();
	system("pause");
	return 0;
}

十一、常对象和常函数
1.常函数
在成员函数后面加const ， 修饰的是this指向，让指针指向的值也不可修改
想修改时：
mutable int m_b;//特殊变量，即时在常函数中，也可以修改

class Person
{
public:
	//都会隐含this指针，this指针是指针常量，  指针的指向不可改变
	//const Person *const this;
	//在成员函数后面加const ， 修饰的是this指向，让指针指向的值也不可修改
	void showPerson() const
	{
		//this->m_age = 199;
		this->m_b = 11;
		//this = NULL;//this指针指向的值不可修改
	}
	void show()
	{

	}
	int m_age;
	mutable int m_b;//特殊变量，即时在常函数中，也可以修改
};

2.常对象

void test02()
{
	const Person p; //在对象前加const ,变为常对象

	p.m_age = 123;
	p.m_b = 23;//m_b是特殊值，在常对象也可以修改
	p.show();//常对象不可调用普通成员函数，因为普通成员函数可以修改属性
    //常对象只能调用常函数。
}

总和代码如下：

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

//常函数
class Person
{
public:
	//都会隐含this指针，this指针是指针常量，  指针的指向不可改变
	//const Person *const this;
	//在成员函数后面加const ， 修饰的是this指向，让指针指向的值也不可修改
	void showPerson() const
	{
		//this->m_age = 199;
		this->m_b = 11;
		//this = NULL;//this指针指向的值不可修改
	}
	void show()
	{

	}
	int m_age;
	mutable int m_b;//特殊变量，即时在常函数中，也可以修改
};
void test01()
{
	Person p;
	p.showPerson();
}

//常对象
void test02()
{
	const Person p; //在对象前加const ,变为常对象

	p.m_age = 123;
	p.m_b = 23;//m_b是特殊值，在常对象也可以修改
	p.show();//常对象不可调用普通成员函数，因为普通成员函数可以修改属性
    //常对象只能调用常函数。
}
int main()
{
	test01();
	//test02();
	system("pause");
	return 0;
}

我的天，终于把对象特性学完了，撒花撒花~

荏苒冬春去^
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cpp代码-c++学习笔记——类与对象
07-14
继承是面向对象编程的重要特性，允许一个类（子类或派生类）从另一个类（基类或父类）继承属性和行为。这有助于代码重用和构建分层的类结构。继承使用冒号`:`表示，例如： ```cpp class Student : public Person { ...
C++整理笔记word版——01 C++学习笔记
12-05
C++是一种强大的面向对象编程语言，它源自C语言并扩展了其功能，包括类、模板、异常处理等高级特性。以下是对C++基础知识点的详细解释： 1. **空头程序**：C++中的空头程序是一个没有实际操作的简单程序，通常用于...
类和对象的特性（C++谭浩强第三版笔记)
weixin_42645653的博客
06-29 699
从程序结构上看：   基于过程的程序中：围绕功能进行的，函数是构成程序的基本部分，程序面对的是一个个函数。   面向对象的程序中：除主函数外，其他函数基本上都出现在“类”中，只有通过类才能调用类中的函数。程序的基本构成单元是类，程序面对的是一个一个的类和对象。   面向对象程序设计四个主要特点：抽象、封装、继承和多态性。 PS：面向过程的程序设计思路更像是数学解题，分清步骤，先做什么，再做什么。 面向对象的程序设计思路更偏向现实，分别设计细节，最终在进行组装。 1.对象： 万物皆可看做对象。对象是构成系统的
【C++学习笔记】九、c++中类和对象的特性
zl3090的博客
01-24 340
本文主要是谭浩强老师c++教材第三版第八章的小结。 1. 面向对象编程 （1）类和对象 对象：具有属性和行为的事物，在程序中体现为具有数据与函数结构； 类：类是对象的抽象，对象是类的特例，即具体表现形式。 （2）面向对象编程特点 凡是以类对象为基本构成单位的程序称为基于对象的程序，面向对象的编程有4个主要特点：抽象、封装、继承和多态。 抽象：概括同一类事物的本质。如：张三、李四、王五...
C++学习笔记4（类和对象之对象特性）
weixin_57029128的博客
10-26 457
学习记录
C++学习笔记----------类和对象（三大特性之一）
九霄云客的博客
06-13 910
类和对象是C++语言区别与C语言的第一个特性，对于新接触C++语言的小白来说至关重要。 1.简论： 实验1： 设计一个圆类Circle，该类有数据成员圆心坐标（x,y）、半径r，同时具有以下功能： （1）初始化圆心坐标和半径 （2）显示圆心坐标和半径 （3）计算圆面积 在主函数中，定义对象来测试该类的声明。 #include<iostream> using namespace s...
C++学习笔记14-类和对象-对象特性
拒绝任何因懒惰而生的省略号
03-01 719
类和对象-对象特性14.0 前言14.1 构造函数和析构函数 14.0 前言 生活中我们买的电子产品都基本会有出厂设置[在某一天我们不用时候也会删除一些自己信息数据保证安全。 C++中的面向对象来源于生活，每个对象也都会有初始设置以及对象销毁前的清理数据的设置。 14.1 构造函数和析构函数 对象的初始化和清理也是两个非常重要的安全问题 　　　一个对象或者变量没有初始状态，对其使用后果是未知。 　　　同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题 。 C++利用了构造函数和析构函数解决
C++学习笔记(13)——利用对象、引用、指针调用虚函数.pdf
最新发布
02-27
在C++编程语言中，虚...总的来说，理解和掌握虚函数的使用是C++中实现面向对象设计的关键，它允许代码更加灵活，具有更好的扩展性和可维护性。在设计类层次结构时，合理地运用虚函数可以提高程序的复用性和可适应性。
C++学习笔记(13)——利用对象、引用、指针调用虚函数.docx
02-27
在C++中，虚函数是实现多态性的重要机制，特别是在面向对象编程中。当一个类含有虚函数时，编译器会为该类创建一个虚拟表（VTABLE），其中包含了类中所有虚函数的地址。这个VTABLE使得在运行时能够根据对象的实际...
c++类与对象 -- 学习笔记
m0_67711803的博客
09-28 147
面向过程与面向对象： c语言是面向过程的，关注的是过程，分析解决问题的步骤，通过函数逐步解决问题。 优势：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源，比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。 弊端：没有面向对象易维护、易复用、易扩展 c++是基于面向对象的，关注的是对象，将一件事拆成不同的对象，通过对象交互解决问题 优势：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加
【C++学习笔记】C++类和对象
qq_41854911的博客
08-04 1352
文章目录C++类的定义和对象的创建详解类的定义创建对象访问类的成员使用对象[指针](http://c.biancheng.net/c/80/)总结C++类的成员变量和成员函数详解在类体中和类体外定义成员函数的区别C++类成员的访问权限以及类的封装简单地谈类的封装对private和public的更多说明C++对象的内存模型C++函数编译原理和成员函数的实现C++函数的编译成员函数的调用C++构造函数详解构造函数的重载默认构造函数C++构造函数初始化列表初始化 const 成员变量C++析构函数详解析构函数的执
C++学习笔记【类和对象】
weixin_43682638的博客
12-14 1091
一、构造函数调用规则 只要自己定义了拷贝构造函数，就必须也要定义构造函数。
C++学习笔记-类和对象
cuihwchn的博客
02-24 339
C++学习笔记-类和对象
C++基础篇--类与对象
小白杨的博客
03-18 233
类的定义：（假设定义一个名为First的类） class First //define a class { private: int somedata; //class data public: void setdata(int d) { somedata = d; } void showd...
c++_类与对象初步了解思维导图
chenzhanpeng_
04-30 700
[C++系列] 33. 思维导图---类和对象
Y-puyu 的博客
04-14 1892
类与对象终结版思维导图！
第7周项目3-第8章(类和对象的特性)思维导图
想去海邊
04-17 876
这辈子绝对不要当老师，这么点东西就用了快两个小时，老师备课太麻烦了，，，感谢贺老平时的付出，，，下面上图。 用Xmind做的，感觉做得还行，个人比较喜欢这样的风格，虽然有些紧凑，但是那种四面八方延伸的会让我感觉没有层次感以至于不大愿意去看。 第9章的明天上午再做，，，暂时实在没有心思再做一张了。。。
c++类和对象2——对象的初始化和清理
qq_45923342的博客
04-26 198
对象的初始化和清理—构造函数和析构函数 #include <iostream> using namespace std; /*生活中我们买的电子产品都会有出厂设置，在某一天我们不用时也会删除一些自己信息数据安全 C++中的面向对象源于生活，每个对象也都会有初始化设置和清理数据设置*/ /*对象的初始化和清理也是两个非常重要的安全问题 一个对象或者变量没有初始状态...
最low的职工管理系统（c++面向对象）
dinnersize的博客
06-10 535
c++面向对象部分学完了，做个项目熟悉一下，总体应用了多态，继承，类的方法。 知识补充： //打开方式 ios::trunc 如果存在，删除文件并重新创建 //打开方式 ios::trunc 如果存在，删除文件并重新创建 ofstream ofs(FILENAME,ios::trunc); ofs.close(); 下面进入项目： 我们有5个头文件，如下 WorkerManager.h #pragma once //防止头文件重复包含 #include<iostream&gt
C++面向对象编程：继承与学习指南
"这篇文档是关于C++编程中面向对象编程的继承概念的学习笔记，主要介绍了C++中的继承机制以及面向对象程序设计的基本思想。同时，文档提到了C++的发展历史，行业地位以及其在不同领域的应用。" 在面向对象编程...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值