【C++核心编程】4 类和对象-对象特性

最新推荐文章于 2024-07-23 22:52:19 发布
最新推荐文章于 2024-07-23 22:52:19 发布
阅读量235 收藏
点赞数
分类专栏： C++核心编程 C++ 文章标签： c++ 编程语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43058281/article/details/113953087
版权

【C++核心编程】4 类和对象-对象特性


黑马程序员匠心之作|C++教程从0到1入门编程
学习笔记
本阶段主要针对C++ 面向对象编程技术做详细讲解，探讨C++中的核心和精髓

4.2 对象的初始化和清理

每个对象都会有初始设置以及对象销毁前的清理数据的设置。

4.2.1 构造函数和析构函数

这两个函数由编译器自动调用。对象的初始化和清理是强制要我们做的事情。如果我们不提供构造和析构，编译器会提供，但是编译器提供的构造函数和析构函数是空实现。

  • 构造函数：主要为成员对象进行初始化赋值操作，由编译器自动调用，无需手动调用。
  • 析构函数：用于对象销毁前系统自动调用，执行一些清理工作。

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

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

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

  1. 析构函数，没有返回值也不写void
  2. 函数名称与类名相同，在名称前加~
  3. 构造函数不可以有参数，因此不可以发生重载
  4. 程序在对象销毁前会自动调用析构，且只会调用一次
    示例：
#include<iostream>
using namespace std;
#include<string>

//对象的初始化和清理

class Person {
	//构造函数 进行初始化操作
	//1. 构造函数，没有返回值也不写void
	//2. 函数名称与类名相同
	//3. 构造函数可以有参数，因此可以发生重载
	//4. 程序在调用对象的时候会自动调用构造，且只会调用一次
public:
	Person() {
		cout << "Person构造函数的调用" << endl;
	}
	//析构函数 进行清理操作
	//1. 析构函数，没有返回值也不写void
	//2. 函数名称与类名相同，在名称前加~
	//3. 构造函数不可以有参数，因此不可以发生重载
	//4. 程序在对象销毁前会自动调用析构，且只会调用一次
	~Person() {
		cout << "Person析构函数的调用" << endl;
	}
};
//对象的初始化和清理是强制要我们做的事情。如果我们不提供构造和析构，编译器会提供，但是编译器提供的构造函数和析构函数是空实现。
void test01() {
	Person p;//并没有调用任何函数,在栈上的数据，test01执行完后释放这个对象
}

int main() {
	test01();
	Person p;//只有构造没有析构函数，因为还未释放
	system("pause");
	return 0;

}

输出：

Person构造函数的调用
Person析构函数的调用
Person构造函数的调用

4.2.2 构造函数的分类及使用

两种分类方式：
1.按参数分：有参构造和无参构造
2.按类型分：普通构造和拷贝构造

三种调用方法：
1.括号法
注意事项：
调用默认构造的时候，不要加()，因为Person p1();这行代码，编译器会认为是一个函数的声明，不会认为是在创建对象
2.显示法
3.隐式转换法
注意事项：
不要利用拷贝构造函数来初始化匿名对象,编译器会认为Person(p3)===Person p3; 误认为是Person(p3)对象声明

示例：

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

//构造函数两种分类方式：
//按参数分：有参构造和无参构造
//按类型分：普通构造和拷贝构造
class Person {
public:
	//构造函数
	Person(int a) {//有参构造
		age = a;
		cout << "Person有参构造函数调用" << endl;
	}
	Person() {//无参构造（默认构造）
		cout << "Person无参构造函数调用" << endl;
	}
	//拷贝构造
	Person(const Person &p) {//将传入的人身上所有属性，拷贝一份一模一样的数据，但不改变本体
		age = p.age;
		cout << "Person拷贝构造函数调用" << endl;
	}
	~Person() {
		cout << "Person析构函数调用" << endl;
	}
	int age;
};
//三种调用方法：
//括号法
//显示法
//隐式转换法
void test01() {
	//括号法
	cout << "括号法:" << endl;
	Person p1;//默认构造函数的调用
	//注意事项：
	//调用默认构造的时候，不要加()
	//因为Person p1();这行代码，编译器会认为是一个函数的声明，不会认为是在创建对象
	
	Person p2(10);//有参构造函数调用
	Person p3(p2);//拷贝构造函数调用
	cout << "p2的年龄为" << p2.age << endl;
	cout << "p3的年龄为" << p3.age << endl;

	//显示法;
	cout << "\n" << "显示法：" << endl;
	Person p4;
	Person p5 = Person(10);//有参构造
	Person p6 = Person(p5);//拷贝构造
	Person(10);//这是个匿名对象，当前行执行结束后，系统会立即回收掉匿名对象
	cout << "aaaa" << endl;//对象被销毁掉以后才打印
	//注意事项：
	//不要利用拷贝构造函数 初始化匿名对象,编译器会认为Person(p3)===Person p3;	Person(p3)对象声明
	//Person(p3);//报错，重定义

	//隐式构造法;
	cout << "\n" << "隐式构造法：" << endl;
	Person p7 = 10;//相当于写了Person p7 = Person(10);
	Person p8 = p7;//拷贝构造
	cout << "\n" << endl;

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

}

输出：

括号法:
Person无参构造函数调用
Person有参构造函数调用
Person拷贝构造函数调用
p2的年龄为10
p3的年龄为10

显示法：
Person无参构造函数调用
Person有参构造函数调用
Person拷贝构造函数调用
Person有参构造函数调用
Person析构函数调用
aaaa

隐式构造法：
Person有参构造函数调用
Person拷贝构造函数调用


Person析构函数调用
Person析构函数调用
Person析构函数调用
Person析构函数调用
Person析构函数调用
Person析构函数调用
Person析构函数调用
Person析构函数调用

4.2.3 拷贝构造函数调用时机

三种情况：

  1. 使用一个已经创建完毕的对象来初始化一个新对象
  2. 值传递的方式给函数参数传值
  3. 以值方式返回局部对象

示例：

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

class Person {
public:
	//构造函数
	Person() {//无参构造（默认构造）
		cout << "Person无参构造函数调用" << endl;
	}
	Person(int age) {//有参构造
		m_age = age;
		cout << "Person有参构造函数调用" << endl;
	}
	//拷贝构造
	Person(const Person &p) {//将传入的人身上所有属性，拷贝一份一模一样的数据，但不改变本体
		m_age = p.m_age;
		cout << "Person拷贝构造函数调用" << endl;
	}
	~Person() {
		cout << "Person析构函数调用" << endl;
	}
	int m_age;
};


//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
	cout << "第一种案例" << endl;
	Person p1(20);
	Person p2(p1);
	cout << "p2的年龄" << p2.m_age << endl;
}
//2. 值传递的方式给函数参数传值
void doWork(Person p) {//p是拷贝出来的
	
}
void test02() {
	cout << "\n" << "第二种案例" << endl;
	Person p;
	doWork(p);
}
//3. 以值方式返回局部对象
Person doWork2() {
	Person p1;//局部对象，会马上被释放掉
	cout << (int*)&p1 << endl;//打印地址
	return p1;//根据p1创建一个新的对象，然后返回给test03
}
void test03() {
	cout << "\n" << "第三种案例" << endl;
	Person p = doWork2();
	cout << (int*)&p << endl;//打印地址，不是同一个地址了
}
int main() {
	test01();
	test02();
	test03();
	system("pause");
	return 0;

}

输出：

第一种案例
Person有参构造函数调用
Person拷贝构造函数调用
p2的年龄20
Person析构函数调用
Person析构函数调用

第二种案例
Person无参构造函数调用
Person拷贝构造函数调用
Person析构函数调用
Person析构函数调用

第三种案例
Person无参构造函数调用
006FFCC4
Person拷贝构造函数调用
Person析构函数调用
006FFDBC
Person析构函数调用

4.2.4 构造函数调用规则

默认情况下，C++编译器至少给一个类添加3个函数

  1. 默认构造函数（无参，函数体为空）
  2. 默认析构函数（无参，函数体为空）
  3. 默认拷贝函数，对属性进行值拷贝

示例：

#include<iostream>
using namespace std;
#include<string>
class Person {
public:
	//构造函数
	Person() {//无参构造（默认构造）
		cout << "Person无参构造函数调用" << endl;
	}
	Person(int age) {//有参构造
		m_age = age;
		cout << "Person有参构造函数调用" << endl;
	}

	~Person() {
		cout << "Person析构函数调用" << endl;
	}
	int m_age;
};
void test01() {
	Person p;
	p.m_age = 18;
	Person p2(p);
	cout << "p2的年龄为" << p2.m_age << endl;//默认添加了拷贝函数
}

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

输出：

Person无参构造函数调用
p2的年龄为18
Person析构函数调用
Person析构函数调用

构造函数调用规则如下：

  1. 如果用户定义有参构造函数，C++不再提供默认无参构造，但是会提供默认拷贝构造
    示例：
#include<iostream>
using namespace std;
#include<string>
class Person {
public:

	Person(int age) {//有参构造
		m_age = age;
		cout << "Person有参构造函数调用" << endl;
	}

	~Person() {
		cout << "Person析构函数调用" << endl;
	}
	int m_age;
};
void test02() {
	//Person p;//报错，因为用户写了有参构造，编辑器不再自动提供默认构造参数
	Person p(28);
	Person p2(p);
	cout << p2.m_age << endl;//写了有参构造，编译器还是会提供拷贝构造
}

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

}

输出：

Person有参构造函数调用
28
Person析构函数调用
Person析构函数调用
  1. 如果用户定义拷贝构造函数，C++不再提供其他构造函数

示例：

#include<iostream>
using namespace std;
#include<string>
class Person {
public:

	//拷贝构造
	Person(const Person &p) {//将传入的人身上所有属性，拷贝一份一模一样的数据，但不改变本体
		m_age = p.m_age;
		cout << "Person拷贝构造函数调用" << endl;
	}

	~Person() {
		cout << "Person析构函数调用" << endl;
	}
	int m_age;
};
void test03() {
	//Person p;//报错，因为用户写了拷贝构造，编辑器不再自动提供默认构造参数
	//Person p(28);//报错，用户写了拷贝构造，编译器不再提供有参构造
}
int main(){
	test03();
	system("pause");
	return 0;

}

4.2.5 深拷贝与浅拷贝

面试重点考点

浅拷贝：简单的赋值拷贝操作
示例：

#include<iostream>
using namespace std;

//深拷贝与浅拷贝
class Person {
public:
	//构造函数
	Person() {//无参构造（默认构造）
		cout << "Person无参构造函数调用" << endl;
	}
	Person(int age,int height) {//有参构造
		m_age = age;
		m_Height = new int(height);//在堆区中的数据 需要工程师手动开启手动释放
		cout << "Person有参构造函数调用" << endl;
	}

	~Person() {//先进后出，p2先释放
		//析构代码，将堆区开辟数据做释放操作
		if (m_Height != NULL) {
			delete m_Height;
			m_Height = NULL;
		}
		cout << "Person析构函数调用" << endl;
	}
	int m_age;
	int *m_Height;//身高
};

void test01() {
	
	Person p1(18,160);
	cout << "p1的年龄为：" << p1.m_age <<"身高为"<<*p1.m_Height<< endl;
	Person p2(p1);//浅拷贝 如果利用编译器提供的拷贝构造函数，会做浅拷贝操作
	cout << "p2的年龄为：" << p2.m_age << "身高为" << *p2.m_Height << endl;
}
int main() {
	system("pause");
	return 0;
}

这段代码会报错，因为Person p2(p1)是浅拷贝操作，对于int *m_Height，浅拷贝带来的问题就是堆区的内存重复释放。

深拷贝：

  • 在堆区重新申请空间，进行拷贝工作
  • 浅拷贝的问题要利用深拷贝来进行解决。

示例：

#include<iostream>
using namespace std;

//深拷贝与浅拷贝
class Person {
public:
	//构造函数
	Person() {//无参构造（默认构造）
		cout << "Person无参构造函数调用" << endl;
	}
	Person(int age,int height) {//有参构造
		m_age = age;
		m_Height = new int(height);//在堆区中的数据 需要工程师手动开启手动释放
		cout << "Person有参构造函数调用" << endl;
	}

	//自己实现拷贝构造函数 解决浅拷贝带来的问题
	Person(const Person &p) {
		cout << "Person拷贝构造函数调用" << endl;
		m_age = p.m_age;
		//m_Height=p.m_Height;//编译器默认实现这行代码
		//深拷贝操作
		m_Height = new int(*p.m_Height);//重新在堆区申请一块内存
	}
	~Person() {//先进后出，p2先释放
		//析构代码，将堆区开辟数据做释放操作
		if (m_Height != NULL) {
			delete m_Height;
			m_Height = NULL;
		}
		cout << "Person析构函数调用" << endl;
	}
	int m_age;
	int *m_Height;//身高
};

void test01() {
	
	Person p1(18,160);
	cout << "p1的年龄为：" << p1.m_age <<"身高为"<<*p1.m_Height<< endl;
	Person p2(p1);//浅拷贝 如果利用编译器提供的拷贝构造函数，会做浅拷贝操作
	cout << "p2的年龄为：" << p2.m_age << "身高为" << *p2.m_Height << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

输出：

Person有参构造函数调用
p1的年龄为：18身高为160
Person拷贝构造函数调用
p2的年龄为：18身高为160
Person析构函数调用
Person析构函数调用

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

4.2.6 初始化列表

作用：用来初始化属性
语法：构造函数() : 属性1（值1），属性2（值2）...{}
传统初始化操作：

#include<iostream>
using namespace std;

class Person {
public:
	//传统初始化操作
	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(10, 20, 30);
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

初始化列表初始化属性：

#include<iostream>
using namespace std;

class Person {
public:
	//初始化列表初始化属性
	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(30,20,10);
	cout << "m_A = " << p.m_A << endl;
	cout << "m_B = " << p.m_B << endl;
	cout << "m_C = " << p.m_C << endl;
}
int main() {
	test01();
	system("pause");
	return 0;
}

4.2.7 类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员

class A{}
class B
{
	A a;
}

B类中对象A作为成员，A为对象成员
示例：

#include<iostream>
using namespace std;
#include<string>
class Phone {
public:
	Phone(string pName) {
		cout << "Phone构造函数调用" << endl;
		m_PName = pName;
	}
	~Phone() {
		cout << "Phone析构函数调用" << endl;
	}
	string m_PName;
};


class Person {
public:
	//Phone m_Phone = pName 隐式转换法
	Person(string name, string pName) :m_Name(name), m_Phone(pName) {
		cout << "Person构造函数调用" << endl;
	}
	~Person() {
		cout << "Person析构函数调用" << endl;
	}
	//姓名
	string m_Name;
	//手机
	Phone m_Phone;
};


//构造函数调用顺序：当其他类对象作为本类成员，先构造其他类对象，在构造自身
//析构函数调用顺序：与构造顺序相反
void test01() {
	Person p("张三", "iphone8");
	cout << p.m_Name << "手机品牌是" << p.m_Phone.m_PName << endl;

}

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

输出：

Phone构造函数调用
Person构造函数调用
张三手机品牌是iphone8
Person析构函数调用
Phone析构函数调用

总结：

  • 构造函数调用顺序：当其他类对象作为本类成员，先构造其他类对象，在构造自身
  • 析构函数调用顺序：与构造函数调用顺序相反

4.2.8 静态成员

静态成员函数

  • 所有对象共享同一个函数
  • 静态成员函数只能访问静态成员变量
    原因：假设Person p1调用函数func,虽然是p1在调用，但是函数体内无法区分是p1在调用

两种访问方式：

  1. 通过对象访问
  2. 通过类名访问

注意事项：
静态成员函数也是有访问权限的

示例：

#include<iostream>
using namespace std;
#include<string>
//静态成员函数
//所有对象共享同一个函数
//静态成员函数只能访问静态成员变量

class Person {
public:
	//静态成员函数
	static void func() {
		m_A = 100;//静态成员函数可以访问静态成员变量，因为m_A是共享的，大家都用一份
		//m_B = 200;//报错，静态成员函数不可以访问非静态成员变量，无法区分到底是哪个对象的m_B属性
//原因：假设Person p1调用函数func,虽然是p1在调用，但是函数体内无法区分是p1在调用
		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 test01() {
	//1.通过对象访问
	Person p;
	p.func();
	//2. 通过类名访问
	Person::func();

	//Person::func2();//类外访问不到私有静态成员函数
}
int main() {
	test01();
	system("pause");
	return 0;
}

4.3 C++对象模型和this指针

4.3.1 成员变量和成员函数分开存储

C++中，类内的成员变量和成员函数分开存储。
只有非静态成员变量才属于类的对象上，非静态函数和非静态变量也分开存储。
示例：

#include<iostream>
using namespace std;

class Person {

};

class Person2 {
	int m_A;//非静态成员变量 属于类的对象上的
};

class Person3 {
	int m_A;
	static int m_B;//静态成员变量 不属于类的对象上
};
int Person3::m_B = 0;//静态成员类外声明

class Person4 {
	int m_A;
	static int m_B;
	void func() {//非静态成员函数 独一无二一份 不属于类的对象上

	}
};

class Person5 {
	int m_A;
	static int m_B;
	void func() {//非静态成员函数 独一无二一份 不属于类的对象上

	}
	static void func2() {//静态成员函数 不属于类的对象上

	}
};

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

void test02() {
	//不是空的，就按int来分配
	Person2 p2;
	cout << "size of p2 = " << sizeof(p2) << endl;//4字节
}

void test03() {
	Person3 p3;
	cout << "size of p3 = " << sizeof(p3) << endl;//4字节
}

void test04() {
	Person4 p4;
	cout << "size of p4 = " << sizeof(p4) << endl;//4字节
}

void test05() {
	Person5 p5;
	cout << "size of p5 = " << sizeof(p5) << endl;//4字节
}
int main() {
	test01();
	test02();
	test03();
	test04();
	test05();
	system("pause");
	return 0;
}

输出：

size of p = 1
size of p2 = 4
size of p3 = 4
size of p4 = 4
size of p5 = 4

4.3.2 this指针概念

每一个非静态成员函数只会调用一份函数示例，也就是说多个同类型的对象会共用一块代码，那么如何区分呢？

C++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象。

this指针是隐含每一个非静态成员函数内的一种指针，不需要定义，直接使用即可。

this指针的用途：

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

示例：

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

class Person {
public:
	Person(int age) {
		//this指针指向被调用成员函数所属的对象，此处this指向p1
		this->age = age;
	}

	//要用引用的方式做一个返回，如果返回的是值会创建一个新的对象
	Person& PersonAddAge(Person &p) {
		this->age += p.age;
		//this是指向p2的指针，*this是指向p2的本体
		return *this;
	}
	int age;
};
//1. 解决名称冲突
void test01() {
	Person p1(18);
	cout << "p1的年龄：" << p1.age << endl;
}
//2. 返回对象本身用*this
void test02() {
	Person p1(10);
	Person p2(11);

	//链式编程思想 可以无限往后追加
	p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1);
	cout << "p2的年龄为：" << p2.age << endl;
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}

输出：

p1的年龄：18
p2的年龄为：41

4.3.3 空指针访问成员函数

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

#include<iostream>
using namespace std;

//空指针调用成员函数
class Person {
public:
	void showClassName() {
		cout << "this is Person class" << endl;
	}
	void showPersonAge() {

		//报错原因是传入的指针为空，空指针不能访问属性
		if (this == NULL) {
			return;
		}
		cout << "age:" << m_age << endl;//相当于this->m_age
	}
	int m_age;
};

void test01() {
	Person *p = NULL;
	p->showClassName();//可以调用
	p->showPersonAge();
}
int main() {
	test01();
	system("pause");
	return 0;
}

输出：

this is Person class

4.3.4 const修饰成员函数

常函数：

  • 成员函数加const后的叫常函数
  • 不可以修改成员属性
  • 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

  • 声明对象前加const后叫常对象
  • 常对象只能调用常函数

示例：

#include<iostream>
using namespace std;

//常函数
class Person {
public:
	//this指针的本质时指针常量，指针的指向是不可以修改的，但是this指针的值是可以修改的
	//this 相当于Person * const this;
	//在函数体后面加const后相当于const Person * const this;指针的值也不可以改
	void showPerson() const{//const修饰的是this指针
		//m_A = 100;//报错，相当于有this->m_A
		this->m_B = 100;
	}
	void func() {

	}
	int m_A;
	mutable int m_B;//特殊变量，即使在常函数中也可以修改。加上关键字mutable
};
void test01() {
	Person p;
	p.showPerson();
}
//常对象
void test02() {
	const Person p;//在对象前加一个const，变为常对象
	//p.m_A = 100;//报错，不能修改
	p.m_B = 100;//m_B在常对象下也可以修改

	//常对象只能调用常函数
	p.showPerson();
	//p.func();//报错，常对象不可以调用普通成员函数，因为普通成员函数可以修改属性
}
int main() {
	test01();
	test02();
	system("pause");
	return 0;
}
Wwwilling
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
普通构造函数和拷贝构造函数，有参构造和无参构造
java领域博主
04-05 1207
普通构造函数和拷贝构造函数，有参构造和无参构造
C++之对象特性
qq_68066657的博客
08-16 409
大概白话理解，就是在创建对象参数的时候有些指针类型的属性创建在堆区，在有对象进行拷贝操作的时候，如果调用的时编译器自带的拷贝构造函数，就会导致两个对象的属性指向同一块内存空间，在析构释放时，拷贝对象（P2）会先释放掉指向的那块内存空间，被拷贝对象（p1)在析构释放时会要求再释放一遍，这就导致了同一块内存空间重复释放的问题，解决办法就是自己写一个拷贝构造函数，在自己写的拷贝构造函数里，把指针类型的属性数据重新开辟一块空间（深拷贝）。浅拷贝：简单的赋值拷贝操作，编译器提供的拷贝构造函数里提供的操作都是浅拷贝。.
class学习（一）构造函数的分类和调用
wanxiangzx的博客
11-02 312
1.保护权限和私有权限类外不可访问。 2.struct 默认权限是public，class默认权限是private。 3.构造函数的分类： 按参数分为：有参构造和无参构造 按类型分为：普通构造和拷贝构造 4.构造函数的调用: 括号法 Person p1; 注意调用默认构造函数不要写成Person p1(); ...
【C++】类和对象-对象特性
debug...
07-04 884
C++类对象特性
class对象特性（初始化和清理）——（１）构造函数的分类和调用
u010596736的博客
08-29 162
构造函数的分类和调用
第四部分—C++核心编程_4. 类和对象
qq_43205256的博客
08-08 256
定义一个结构体用来表示一个对象所包含的属性，函数用来表示一个对象所具有的行为，这样我们就表示出来一个事物，在c语言中，行为和属性是分开的，也就是说吃饭这个属性不属于某类对象，而属于所有的共同的数据，所以不单单是PeopleEat可以调用Person数据，AnimalEat也可以调用Person数据，那么万一调用错误，将会导致问题发生。对象的初始化和清理也是两个非常重要的安全问题，一个对象或者变量没有初始时，对其使用后果是未知，同样的使用完一个变量，没有及时清理，也会造成一定的安全问题。...........
C++类和对象的学习【part2：对象特性】
qq_41883714的博客
11-05 89
C++类和对象的学习【part2：对象特性】 构造函数和析构函数 完成对对象的初始化和清理。 编译器强制，自动调用。 构造函数语法： 类名（）{}
13-C++课件-面向对象高级编程-p110
06-04
总之，面向对象高级编程是C++的核心，涉及到类的设计、对象的创建和操作，以及类之间的关系。通过学习这些概念，开发者能够编写出更加高效、可维护的代码。同时，理解C++的历史和标准演进，有助于更好地理解和利用...
C++核心编程讲义和相关代码
02-15
在"C++核心编程讲义和相关代码"中，我们将会深入探讨C++的基础概念、核心特性以及实际应用。这份讲义和代码集合是学习C++编程的理想资源，它将理论与实践相结合，帮助读者建立起坚实的C++编程基础。 1. **C++基础...
C++面向对象程序设计课程大作业-通讯录管理系统
05-21
C++是支持OOP的重要编程语言，提供了类（Class）、对象（Object）、继承（Inheritance）、多态（Polymorphism）等特性。 1. **类与对象**：在C++中，类定义了一种数据结构，它是对象的蓝图。对象是类的实例，包含了...
c++语言程序设计课件_C语言教程_C++程序设计--类与对象_
09-30
C++的面向对象特性还包括封装、继承和多态。封装是将数据和操作数据的方法捆绑在一起，形成一个独立的实体，这样可以隐藏内部实现细节，只对外提供接口。继承允许一个类（子类）继承另一个类（父类）的属性和方法，...
剖析C++的面向对象编程思想
09-03
总之，C++的面向对象特性使其成为编写大型、复杂系统的一种强大工具。理解并熟练掌握面向对象编程，不仅能够提升代码质量，还能提高开发效率，使软件的维护和扩展变得更加容易。在实践中，我们需要不断地探索和实践...
C++进阶中继承的全部主要内容
2302_80214413的博客
07-22 501
这次小编给大家带来了很全面的C++进阶的继承方面的内容，代码及其注释和解释肯定可以给大家带来很好的学习体验，希望大家收获满满！~~~
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 224
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
【C++】操作符“new”和“delete”（创建和销毁对象）
qq_65596720的博客
07-19 375
由于C++引入了类的概念所以创建空间和销毁空间变得复杂，使用malloc和free会更加复杂，所以C++引入了new和delete来简化代码。
2024年华为OD机试真题-虚拟游戏理财-C++-OD统一考试（C卷D卷）
面试高手的博客
07-21 9693
现有一家Bank，它提供有若干理财产品m，风险及投资回报不同，你有N（元）进行投资，能接受的总风险值为X。第一行：产品数(取值范围[1, 20])，总投资额(整数，取值范围[1, 10000])，可接受的总风险(整数，取值范围[1, 200])投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10。第四行：最大投资额度序列，输入为整数，取值范围[1,10000]第二行：产品投资回报率序列，输入为整数，取值范围[1,60]第三行：产品风险值序列，输入为整数，取值范围[1,100]
linux C++ onnxruntime yolov8 视频检测Demo
最新发布
.NET 人工智能实践
07-23 196
linux C++ onnxruntime yolov8 视频检测Demo
C语言 打印菱形的程序（Program to print the Diamond Shape）
csdn_aspnet的专栏
07-22 1059
O(n*n)，因为我们正在遍历网格的行和列来打印空格 ' '和星号 '*'。给定一个数字n ，编写一个程序来打印一个有2n行的菱形。O(1)，不使用额外空间。
学懂C语言（二十一）：深入理解C语言中的函数指针和回调函数
martian665的专栏
07-23 100
学懂C语言：C语言中的函数指针和回调函数详解
C++面向对象编程：类与对象详解
"谭浩强的C++教程专注于类和对象的讲解，包括面向对象程序设计的基本概念、类的声明与对象定义、成员函数、对象成员的引用、封装性与信息隐蔽以及面向对象编程的应用实例。" 面向对象程序设计（Object-Oriented ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值