c++类与对象(下)

已于 2023-10-11 17:26:01 修改
阅读量111 收藏
点赞数 1
分类专栏： c++笔记 文章标签： c++ 笔记
于 2023-09-15 16:02:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dong132697/article/details/132872755
版权

文章目录

前言

一、再谈构造函数

1、构造函数体赋值

在创建对象时，编译器通过调用构造函数，给对象中各个成员变量一个合适的初始值。虽然我们之前写的构造函数调用之后，对象中已经有了一个初始值，但是不能将其称为对对象中成员变量的初始化，构造函数体中的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

class Date
{
public:
    Date(int year, int month, int day)
    {
        _year = year;
        _month = month;
        _day = day;
    }
private:
    int _year;
    int _month;
    int _day;
};

当我们定义类的成员时，我们可能会定义const修饰的成员变量，而使用const修饰的变量必须在定义的位置就完成初始化。而我们在下面的代码中虽然在声明时给了_x缺省值，但以后_x变量就不可以改变了，而且有时候我们并不想给_x赋值为缺省值。所以必须给每个成员变量找一个定义的位置，然后在这个位置将这些声明的变量统一进行初始化。
所以c++中在构造函数中还有个初始化列表的概念。

class A
{
private:
//成员变量的声明
	int _a1;
	int _a2;
	//这只是给_x的缺省值，这样定义以后_x变量的值就不能再改变了
	const int _x = 1;
};

int main()
{
	A aa;

	//const修饰的变量必须在定义的位置初始化
	const int i = 0;


	return 0;
}

2、初始化列表

哪个对象调用构造函数，初始化列表是它所有成员变量定义的位置。
初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个"成员变量"后面跟一个放在括号中的初始值或表达式。有了初始化列表，上述我们遇到的问题就可以解决，即我们可以在初始化列表中对const修饰的成员变量进行初始化。并且不管是否显示的在初始化列表中对类成员变量进行初始化，编译器都会在初始化列表中对这些变量进行定义初始化，所以说初始化列表才是真正对类成员变量进行初始化的地方。

class A
{
public:
	A()
	//初始化列表位置，在该位置对const修饰的_x进行初始化
		:_x(5),
		_a1(2)  //此时_a1的缺省值就不会生效了
	//虽然在下面没有写 _a2(4)来给_a2初始化，但是_a2在声明时有缺省值，
	//所以此时编译器会在初始化列表自动对_a2进行初始化为缺省值
	//即 _a2(1)
	{

	}
private:
	//成员变量的声明
	int _a1 = 1;
	int _a2 = 1;
	//这只是给_x的缺省值，这样定义以后_x变量的值就不能再改变了
	const int _x;
};

int main()
{
	A aa;

	//const修饰的变量必须在定义的位置初始化
	const int i = 0;


	return 0;
}

1. 每个成员变量在初始化列表中只能出现一次(初始化只能初始化一次)
2. 类中包含以下成员，必须放在初始化列表位置进行初始化：
(1). 引用成员变量
(2) .const成员变量
(3). 自定义类型成员(且该类没有默认构造函数时
3. 尽量使用初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。

class B
{
public:
	//此时类B的构造函数为有参数的构造函数，而默认构造是不需要传参就可以调用的那一个构造函数
	//所以类B没有默认构造函数，此时如果在A类中声明了B类类型的对象_bb，就需要在A的初始化列表中将_bb初始化
	B(int a)
		:_b(0)
	{
		cout << "B()" << endl;
	}
private:
	int _b;
};
class A
{
public:
	A()
		//初始化列表位置，在该位置对const修饰的_x进行初始化
		:_x(5),
		_a1(2),
		_ref(_a1),
		_bb(2)
		//_a1(3)  //每个成员变量在初始化列表只能初始化一次，所以该语句会报错
	//虽然在下面没有写 _a2(4)来给_a2初始化，但是_a2在声明时有缺省值，
	//所以此时编译器会在初始化列表自动对_a2进行初始化为缺省值
	//即 _a2(1)
	{

	}
private:
	//成员变量的声明
	int _a1 = 1;
	int _a2 = 1;

	//const成员变量，引用成员变量，自定义类型成员变量(并且该类没有默认构造函数时)都必须放在初始化列表位置进行初始化
	const int _x;
	int& _ref;
	B _bb;
};

int main()
{
	A aa;

	//const修饰的变量必须在定义的位置初始化
	const int i = 0;


	return 0;
}

4. 成员变量在类中声明次序就是其在初始化列表中的初始化顺序，与其在初始化列表中的先后次序无关。
例如下面的代码中，虽然在初始化列表中的顺序为先对_a1初始化，再对_a2初始化，但是因为在声明时是先声明的_a2，然后再声明的_a1。所以其实在初始化列表中先执行的是_a2(_a1)，然后再执行_a1(a)，所以该程序的结果为_a1为1，_a2为随机值。

class A
{
public:
	A(int a)
		:_a1(a)
		, _a2(_a1)
	{

	}
	void Print()
	{
		cout << _a1 << " " << _a2 << endl;
	}
private:
	int _a2;
	int _a1;
};

int main()
{
	A aa(1);
	aa.Print();

	return 0;
}

其实类中声明的所有成员变量(包括内置类型和自定义类型)都会走初始化列表，因为那里才是成员变量定义的地方。内置类型成员虽然不需要显示的在初始化列表出现，但是它们的定义也是在初始化列表中定义为随机值，自定义类型成员也会在初始化列表中定义，即会自动调用该自定义类型的默认构造函数(无参构造函数)，如果没有默认构造函数，就需要显示的在初始化列表中调用自定义类型的有参构造函数。

3、explicit关键字

构造函数不仅可以构造与初始化对象，对于单个参数或者除第一个参数无默认值其余均有默认值的构造函数，还具有类型转换的作用。
我们知道当内置类型发生隐式类型转换时，其实在中间生成了一个临时变量。例如下面的例子中。

那么当我们将自定义类型进行这样的隐式类型转换时，是不是也会像内置类型一样中间生成临时对象呢？
答：按逻辑来说应该是这样的，但是我们可以分析一下，如果生成临时对象的话，需要先调用构造函数创建一个临时对象tmp，然后又调用一次拷贝构造函数将tmp拷贝给aa2对象，即发生了两次函数的调用。所以其实编译器会对这个过程进行优化，即会将构造+拷贝构造直接优化为构造。即优化为A aa2(1)这样的效果。但是需要注意的是只有类的构造函数为单个参数或者除第一个参数无默认值其余均有默认值时，才具有类型转换的作用(c++98语法)。
在这里插入图片描述
A类的构造函数为单个参数时。
在这里插入图片描述
A类的构造函数中除第一个参数无默认值其余均有默认值。
在这里插入图片描述
而当我们不想让构造函数具有类型转换功能时，就可以使用explicit关键字修改构造函数，此时如果再像上面那样直接使用A aa2 = 1来创建对象时就会发生错误，因为此时构造函数不可以进行类型转换了。即会直接报出不存在从int转换到A的适当构造函数的错误。即用explicit修饰构造函数，将会禁止构造函数的隐式转换。
在这里插入图片描述
在这里插入图片描述
上面的语法其实是C++98的语法，C++98语法中只支持单参数隐式类型转换，但是在C++11中支持了多参数隐式类型转换。即如果构造函数的参数不为单参数也可以进行隐式类型转换。
在这里插入图片描述

二、static成员

1、概念

声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化。
我们可以想一下这个问题：实现一个类，可以计算出该程序中共创建了多少个类对象？
我们看到这个问题的第一个想法应该就是创建一个全局变量，然后在该类的构造函数和拷贝函数中都对这个全局变量进行+1。但是这样写虽然可以得到这个程序中创建了多少个类对象，但是num为全局变量，是可以随意修改的，所以这个办法是很不安全的。

int num = 0;
class A
{
public:
	A(int a = 0)
	{
		++num;
	}
	A(const A& aa)
	{
		++num;
	}
};
void func(A a)
{

}
int main()
{
	A aa1(5);
	A aa2(aa1);
	A aa3 = aa1;
	func(aa1);
	cout << num << endl;

	return 0;
}

2、特征

1. 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区。
2. 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明。
3. 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问。
4. 静态成员函数没有隐藏的this指针，不能访问任何非静态成员。
5. 静态成员也是类的成员，受public、protected、private 访问限定符的限制。
所以上面的代码我们就可以使用static将num设为静态成员。此时静态成员num不属于某个对象，它属于所有的对象，属于整个类。但是将num设置为静态成员的话还会遇到一个问题，即如果将num声明为private时，外面就不可以访问到num变量，而如果将num声明为public时，此时num又变得不安全，即可以通过对象.num或者A::num修改num的值。

class A
{
public:
	A(int a = 0)
	{
		++num;
	}
	A(const A& aa)
	{
		++num;
	}
//private:
	//静态成员变量不属于某个对象，属于所有对象，属于整个类，即创建出来的所有对象都共享这一个静态成员变量
	static int num;
};
//A类中的静态成员变量定义初始化
//静态成员变量一定要在类外进行初始化
int A::num = 0;  
void func(A a)
{

}
int main()
{
	A aa1(5);
	A aa2(aa1);
	A aa3 = aa1;
	func(aa1);
	//因为静态成员num属于所有对象，属于整个类，所以A::num也可以访问num
	cout << aa1.num << endl;
	cout << A::num << endl;
	//此时并没有对nullptr进行解引用
	A* ptr = nullptr;
	cout << ptr->num << endl;

	return 0;
}

为了解决上面的问题，我们可以再定义一个GetNum()函数用来返回num的值，但是此时如果我们想到的num的值就还需要实例化一个对象，然后再调用该对象的GetNum()方法得到num的值，这又显得很不方便。所以我们可以将GetNum()函数也定义为静态成员函数，即static int GetNum()。这样不但可以通过对象.GetNum()来调用GetNum()函数，也可以通过A::GetNum()来调用GetNum()函数。需要注意的是：静态成员函数中不能访问非静态成员变量，也不能调用非静态成员函数，因为函数内没有this指针。非静态成员函数中可以访问静态成员变量，也可以调用静态成员函数

class A
{
public:
	A(int a = 0)
	{
		//非静态成员函数中可以访问静态成员变量，也可以调用静态成员函数
		GetNum();
		++num;
	}
	A(const A& aa)
	{
		//非静态成员函数中可以访问静态成员变量
		++num;
	}
	void Print()
	{
		cout << _a1 << endl;
	}
	//静态成员函数 -- 没有this指针
	static int GetNum()
	{
		//静态成员函数中不能访问非静态成员变量，也不能调用非静态成员函数，因为函数内没有this指针。
		//_a1;
		//Print();
		return num;
	}
private:
	//静态成员变量不属于某个对象，属于所有对象，属于整个类，即创建出来的所有对象都共享这一个静态成员变量
	static int num;  //声明
	int _a1;
};
//A类中的静态成员变量定义初始化
//静态成员变量一定要在类外进行初始化
int A::num = 0;  
void func(A a)
{

}
int main()
{
	A aa1(5);
	A aa2(aa1);
	A aa3 = aa1;
	func(aa1);
	cout << aa1.GetNum() << endl;
	cout << A::GetNum() << endl;
	//此时并没有对nullptr进行解引用
	A* ptr = nullptr;
	cout << ptr->GetNum() << endl;

	return 0;
}

三、友元

友元提供了一种突破封装的方式，有时提供了便利。但是友元会增加耦合度，破坏了封装，所以友元不宜多用。
友元分为：友元函数和友元类

1、友元函数

友元函数我们在前面实现Date日期类时其实已经用到了，在我们写<<流插入符和>>流提取符的重载函数时，因为因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置，所以我们需要将这两个符号的重载函数设置为全局函数，而设置为全局函数后，又不能访问Date类中的私有成员变量。所以我们用到了友元函数，即在Date类中将这两个符号的重载函数设置为了友元函数，这样就可以在这两个函数中访问Date类中的私有成员变量了。

class Date
{
public:
Date(int year, int month, int day)
     : _year(year)
     , _month(month)
     , _day(day)
 {}
// d1 << cout; -> d1.operator<<(&d1, cout); 不符合常规调用
// 因为成员函数第一个参数一定是隐藏的this，所以d1必须放在<<的左侧
ostream& operator<<(ostream& _cout)
 {
     _cout << _year << "-" << _month << "-" << _day << endl;
     return _cout;
 }
private:
int _year;
int _month;
int _day;
};

友元函数可以直接访问类的私有成员，它是定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰(因为友元函数中没有this指针)
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同

class Date
{
 friend ostream& operator<<(ostream& _cout, const Date& d);
 friend istream& operator>>(istream& _cin, Date& d);
public:
 Date(int year = 1900, int month = 1, int day = 1)
 : _year(year)
 , _month(month)
 , _day(day)
 {}
private:
 int _year;
 int _month;
 int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)
{
 _cout << d._year << "-" << d._month << "-" << d._day;
 return _cout; 
}
istream& operator>>(istream& _cin, Date& d)
{
 _cin >> d._year;
 _cin >> d._month;
 _cin >> d._day;
 return _cin;
}
int main()
{
 Date d;
 cin >> d;
 cout << d << endl;
 return 0;
}

2、友元类

友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
友元关系是单向的，不具有交换性。
比如Time类和Date类，在Time类中声明Date类为其友元类，那么可以在Date类中直接访问Time类的私有成员变量，但想在Time类中访问Date类中私有的成员变量则不行。
友元关系不能传递，如果C是B的友元， B是A的友元，则不能说明C时A的友元。

class Time
{
   friend class Date;   // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
 Time(int hour = 0, int minute = 0, int second = 0)
 : _hour(hour)
 , _minute(minute)
 , _second(second)
 {}
   
private:
   int _hour;
   int _minute;
   int _second;
};
class Date
{
public:
   Date(int year = 1900, int month = 1, int day = 1)
       : _year(year)
       , _month(month)
       , _day(day)
   {}
   
   void SetTimeOfDate(int hour, int minute, int second)
   {
       // 直接访问时间类私有的成员变量
       _t._hour = hour;
       _t._minute = minute;
       _t._second = second;
   }
   
private:
   int _year;
   int _month;
   int _day;
   Time _t;
};

四、内部类

概念：如果一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类并不能越界访问内部类的私有成员。
可以在下面的例子中看到A类类型对象中并没有B类的成员b，这时因为A和B在空间上是独立的。
在这里插入图片描述
内部类B写在A里面和写在全局没有区别，只是受A的类域限制，所以此时如果想要定义一个B类，就要去A类的类作用域里面找。如果去全局找的话，是找不到B类的。
在这里插入图片描述如果将B类在A类中定义为私有，则外面就无法访问到B，也不能创建B对象，即此时B类就只能在A类中创建。
在这里插入图片描述
注意：内部类就是外部类的友元类，内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。即内部类B天生就是A的友元类，所以在B中可以访问A的私有成员，但A不能访问B的私有成员。
在这里插入图片描述
特性：
1. 内部类可以定义在外部类的public、protected、private都是可以的。
2. 注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
3. sizeof(外部类)=外部类，和内部类没有任何关系。

class A
{
public:
	void Print2()
	{
		B bb;
		//但A不能访问B的私有成员。
		//cout << bb.b << endl;
	}
private:
	int h = 1;
	static int num;
	//内部类
	class B
	{
	public:
		void Print(const A& a)
		{
			//内部类B天生就是A的友元类，所以在B中可以访问A的私有成员，但A不能访问B的私有成员。
			cout << a.h << endl;
			// 内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名。
			cout << num << endl;
		}
	private:
		int b = 2;

	};
};
int A::num = 0;

int main()
{
	A aa;
	cout << sizeof(aa) << endl;
	//定义一个内部类B，需要标明B类在A类的类作用域中
	//A::B bb;
	return 0;
}

五、匿名对象

临时对象和匿名对象都具有常型，匿名对象的生命周期只在这一行。

class A
{
public:
	A()
		:_a1(2)
		, _a2(4)
	{
		++num;
	}
	~A()
	{
		cout << "~A()"<<endl;
	}
	int GetNum()
	{
		return num;
	}
private:
	int _a1;
	int _a2;
	static int num;
};
int A::num = 0;

int main()
{
	//不能这样定义对象，因为编译器无法识别下面是一个函数声明还是对象定义
	//A aa1();
	//但是我们可以这么定义匿名对象，匿名对象的特点不用取名字，
	// 但是他的生命周期只有这一行，我们可以看到下一行他就会自动调用析构函数

	A aa2;
	//当我们想查看创建了多少对象时，我们还需要创建一个对象，然后通过该对象调用GetNum()方法来得到num
	cout << aa2.GetNum() << endl;
	//我们也可以创建一个匿名对象，该匿名对象的生命周期只在这一行
	cout << A().GetNum() << endl;

	return 0;
}

六、拷贝对象时的一些编译器优化

1、函数传参的优化

class A
{
public:
	A(int a =10)
		:_a(a)
	{
		cout << "构造函数" << endl;
	}
	A(const A& a)
	{
		_a = a._a;
		cout << "拷贝构造函数" << endl;
	}
	~A()
	{
		cout << "析构函数" << endl;
	}

private:
	int _a;
};

void func1(A aa)
{

}
void func2(const A& aa)
{

}
int main()
{
	A aa1 = 1;  //构造 + 拷贝构造 ->  优化为直接构造
	func1(aa1);  //无优化
	//按逻辑应该是先将2构造为A类型的临时对象tmp，然后调用func1时调用拷贝构造将tmp拷贝给对象aa
	func1(2);  //构造 + 拷贝构造  ->  优化为直接构造
	func1(A(3));  // 构造 + 拷贝构造  ->  优化为直接构造

	cout << "----------------------------" << endl;
	//因为为传引用传参，所以不会进行拷贝函数的构造，所以就不会进行优化
	func2(aa1);  //无优化
	func2(2);  //无优化
	func2(A(3));  //无优化

	return 0;
}

2、传值返回的优化

传值返回在返回时会调用拷贝构造函数，但是编译器进行了优化。
在这里插入图片描述

class A
{
public:
	A(int a = 10)
		:_a(a)
	{
		cout << "构造函数" << endl;
	}
	A(const A& a)
	{
		_a = a._a;
		cout << "拷贝构造函数" << endl;
	}
	~A()
	{
		cout << "析构函数" << endl;
	}

private:
	int _a;
public:
	int b;
};

A func3()
{
	A aa;  //构造函数
	aa.b = 3;
	//没有优化
	return aa;  //此时返回aa对象会调用拷贝构造生成aa对象的拷贝，然后当作返回值返回
}
A func4()
{
	return A(); //构造匿名对象
}
int main()
{
	func3();
	//func3return时会调用一次构造函数，A aa1 = tmp时会调用一次构造函数。但是编译器会将两次拷贝构造函数优化为一次拷贝构造函数
	A aa1 = func3(); // 会将两次拷贝构造函数优化为一次拷贝构造函数。

	func4();  //构造+拷贝构造 ->  优化为构造
	A aa2 = func4();  //构造+拷贝构造+拷贝构造  ->  优化为构造
	return 0;
}

3、总结

函数传参总结：尽量使用const &传参。
对象返回总结：
(1). 接收返回值对象，尽量拷贝构造方式接收，不要赋值接收。

A aa1 = func3();
//而不要分开写，因为分开写就不会进行优化了
A aa1;
aa1 = func3();

(2). 函数中返回对象时，尽量返回匿名对象。

A func4()
{
	//分开写不会进行优化
	//A aa;
	//reutrn aa;
	//一起写才会进行优化
	return A();
}
dong132697
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ 类与对象习题
10-14
C++ 类与对象习题，都是入门知识，给初学者参考^-^
C++类和对象.ppt
11-13
在C++中，类是一种抽象的数据类型，是同种对象的集合与抽象，是具有共同行为和属性的若干对象的统一描述体。类的声明包括类名、成员函数和成员变量的声明。 类的声明 类的声明使用关键字class，后跟类名，例如`...
(C++)类与对象
weixin_53812805的博客
05-22 1万+
一、类与对象的思想 面向对象的特点：封装、继承、多态 面向对象编程的特点： （1）易维护：可读性高，即使改变了需求，由于继承的存在，只需要对局部模块进行修改，维护起来非常方便，维护的成本也比较低。 （2）质量高：可以重用以前项目中已经被测试过的类，使系统满足业务需求从而具有更高的质量 （3）效率高：在软件开发时，根据设计的需求要对现实世界的事物进行抽象，从而产生了类 （4）易扩展：由于继承、封装、多态的特性，可设计出高内聚、低耦合的系统结构，使系统更加灵活、更容易扩展，而且成本也比较低。 1、
C++类和对象详细总结
m0_56910081的博客
04-11 1万+
类与对象概念 什么是对象 对象是一个实体，我们眼睛看到的所有实体都可以看成一个实体对象 什么是类 类是用来对实体（对象）进行描述的。（对象有什么属性，有什么功能）类是一种自定义类型 什么是方法： 方法是实现类功能的一个具体实现，该类有什么样的功能？类的所有功能都要通过调用方法来实现。 自定义类型（类的关键字：class） C中我们学过struct（结构体）自定义类型。c++为了兼容c语言，在这里我们也可以使用struct来定义类。和c不同的是，c++中的struct可以在内部放置函数，除此以
C++类对象进行排序
taoxing
08-29 4868
写在前面 C++类对象按照某一个属性进行排序很早以前就学习过，但是时间久了开始有点遗忘了，现在就把最常用的一共方法进行以下总结。 一. 二.
C++类和对象（一）
ll1175555的博客
07-13 1万+
目录面向过程和面向对象初步认识类的定义类的作用域类的实例化类的访问限定符及封装类的对象大小计算类成员函数this指针 面向过程和面向对象初步认识 C语言是面向过程的，关注的是过程，分析出求解问题的步骤，通过函数调用逐步解决问题。 C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。 比如一个外卖系统 面向过程：下单、接单、送餐三个过程 面向对象：客户、商家、骑手，关注的是三个类对象之间的关系 类的定义 class Name { //类体:由成员函数和成员变量组成
C++类对象的创建方式
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-11 5742
C++类对象的创建方式
C++的类和对象
Cosmicsea的博客
05-21 5111
C++面向对象的三大特性：封装、继承、多态 C++认为万事万物皆可为对象，对象有其属性和行为 具有相同性质的对象，可以抽象为类 封装 类在设计时，可以把属性和行为放在不同的权限下，加以控制 public：公共权限，类内可访问、类外可访问， protected：保护权限，类内可访问、类外不可访问，儿子可以访问父亲的保护内容 private：私有权限，类内可访问、类外不可访问，儿子不可以访问父亲的私有内容 struct和class的区别在于 struct的默认权限是public cla
C++类和对象
wh22141334的博客
07-18 3880
c++中的类和对象
C++类对象的创建与释放过程
m0_37622246的博客
08-16 5529
C++类对象的创建与释放过程类对象的创建过程类对象的释放过程析构函数缺省析构函数 类对象的创建过程 1、分配类所需要的空间，无论是栈还是堆。 2、传递实参调用构造函数，完成如下任务： 1、根据继承表依次调用父类的构造函数。 2、根据成员变量的顺序依次调用成员变量的构造函数。 3、执行构造函数体中的代码。 注意：执行构造函数的代码是整个构造函数的最后一步，要保证构造函数代码所需要的一切资源和先决条件...
C++类和对象数组
热门推荐
夏牧子的博客
05-14 4万+
C++类和对象数组 【1】对象数组 1：对象数组的定义：类名 数组名[元素个数] Eg: student asa[10];//有10个元素的学生类对象数组 2：对象数组的访问形式：数组名[下标].成员名； Eg: asa[j].print(); 3:对象数组的初始化：对象数组的初始化通常也是由构造函数来完成的。 Eg: #include”student.h” int main {...
c++类与对象（初学超详细讲解）
qq_51577238的博客
03-26 7041
c++类与对象 一、类的结构 1、类使用关键词class进行定义，四要素：类名、数据成员、函数成员、访问限定符。 2、访问限定符有：private----私有，public------公有，protected------保护 【注】类的数据类型在默认情况下是private，结构体的数据在默认情况下是public 3、成员函数的定义方式有两种：1）直接在类的内部进行定义 2）在类的内部进行函数的声明，在类的外部进行函数的定义 【注】在外部进行定义时需要使用域作用符 :: ，格式为 返回值类型 类名::函数名
C++ 类和对象基础篇
08-25
"C++ 类和对象基础篇" 本节课程主要讲解了 C++ 中的类和对象基础知识。类是创建对象的模板，一个类可以创建多个对象，每个对象都是类类型的一个变量；创建对象的过程也叫类的实例化。每个对象都是类的一个具体实例...
c++ 类与对象
11-10
c++类与对象实习举例。
c++ 类和对象总结
01-20
类是对象的抽象，而对象是类的具体实例。 2.1 类的引入 在C语言中我们定义一个结构体是这样定义的： struct Student { int _age; char* _Gender; char* _Name; }; int main() { struct S; r
C++之模板（四）
CSDN_HZW的博客
06-18 86
【代码】C++之模板（四）
C语言中的内存动态管理
最新发布
2401_84421190的博客
06-18 410
1.在结构体中2.最后一个成员3.未知大小的数组例如：struct Sint a;char n;double b;int arr[];//未知大小的数组，arr就是柔性数组成员或者struct Sint a;char n;double b;int arr[0];//未知大小的数组，arr就是柔性数组成员。
c++ 6.11
Johan1111的博客
06-11 284
(5)另外， RMB 类还包含一个静态整型成员变量 count，用于记录当前已创建的 RMB 对象的数量。每当创建一个新的 RMB 对象时，count 应该自增 1；(1)重载算术运算符 + 和 -，使得可以对两个 RMB 对象进行加法和减法运算，并返回一个新的 RMB 对象作为结果。(2)重载关系运算符 >，判断一个 RMB 对象是否大于另一个 RMB 对象，并返回 true 或 false。(3)重载前置减减运算符 --，使得每次调用时 RMB 对象的 yuan、jiao 和 fen 分别减 1。
C++之模板（三）
CSDN_HZW的博客
06-18 129
可以将数据结构类型传递进来，比如=vectop<T>（如果没传就是默认）Stack.hmain.cpp。
c++类与对象
05-30
在C++中，使用类和对象可以实现面向对象编程的思想，使程序更加模块化、可维护和易扩展。 下面是一个简单的C++类的示例： ```c++ class Person { private: string name; int age; public: void setName...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值