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++ 类和对象基础篇
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语言经典指针运算笔试题图文解析
喜羊羊的博客
06-12 657
指针运算常常现在面试题中，画图解决是最好的办法。
CSAPP大作业 hello的一生
m0_73927795的博客
06-14 1006
计算机系统大作业 hello的一生
每日一题——Python实现PAT甲级1116 Come on! Let‘s C（举一反三+思想解读+逐步优化）五千字好文
weixin_44915521的博客
06-13 778
这段代码在处理大量数据时表现良好，时间复杂度和空间复杂度都与输入规模成线性关系，效率较高。代码结构清晰，使用了合适的数据结构和算法，是一段高质量的代码。通过以上优化，确保在时间和空间上的复杂度都保持在O(N + K)的水平，而代码的可读性和效率也得到了提升。这段优化后的代码更紧凑，并且在处理查询时更加直接。通过运用以上哲学和编程思想，在优化过程中，既提升了代码的效率，又保持了代码的简洁和可维护性。这些思想不仅可以应用在这段代码中，对于其他编程任务同样适用，是编写高质量代码的重要原则。
C++之拷贝构造
a20040518的博客
06-11 564
C++之拷贝构造
16-C语言中的作用域——函数声明，函数头，局部与全局作用域以及作用域的掩盖
everything is possible，anything is OK.
06-11 564
16-C语言中的作用域——函数声明，函数头，局部与全局作用域以及作用域的掩盖
C++中的指针和引用的区别
2402_84885073的博客
06-15 460
了解这些区别有助于你在编写C++代码时选择使用指针还是引用。通常，如果可能的话，使用引用可以提供更好的安全性和可读性。然而，在某些情况下（如需要处理空值或需要动态修改指向的对象时），指针可能是更好的选择。在C++中，指针和引用都是用于间接访问内存位置的工具，但它们之间存在一些重要的区别。
4 最简单的 C 程序设计—顺序程序设计-4.6 顺序结构程序设计举例
qq_43071699的博客
06-12 146
【代码】4 最简单的 C 程序设计—顺序程序设计-4.6 顺序结构程序设计举例。
C++|哈希结构封装unordered_set和unordered_map
weixin_68201503的博客
06-11 872
上一篇章，学习了unordered系列容器的使用，以及哈希结构，那么这一篇章将通过哈希结构来封装unordered系列容器，来进一步的学习他们的使用以及理解为何是如此使用。其实，哈希表的封装方式和红黑树的封装方式形式上是差不多的，如果有了红黑树的封装理解经验，我相信在理解哈希封装的过程会减少负担的。当然，在使用哈希结构中采用的是更具代表的哈希桶，接下来进行封装。
【C语言】联合（共用体）
2301_79633555的博客
06-12 915
联合体的声明，变量的创建，特点，联合体的大小计算，判断大小端，联合体的优缺点
【C++】多态|原理|override|final|抽象类|多继承虚函数表|对象模型|虚表打印|（万字详解版）
最新发布
m0_67367079的博客
06-16 603
C++11引入了override和final两个关键字，它们增强了面向对象编程中的继承和多态特性，提高了代码的安全性和可读性。虚函数自身自带一个_vfptr的虚函数表子类虚函数继承父类虚函数时，不仅继承父类虚函数表，也可以对虚函数进行重写。子类虚函数继承父类虚函数时，非虚函数不会存放在_vfptr中虚表存的是虚函数指针，不是虚函数，虚函数和普通函数一样的，都是存在代码段的，只是他的指针又存到了虚表中。另外对象中存的不是虚表，存的是虚表指针。
【C++】编译原理
因为热爱所以坚持
06-12 988
三、C++编译 前面给大家演示了如何从写C++代码到编译代码再到执行代码的全过程。这个过程中非常重要的编译环节，被我们一个按钮或者一个ctrl+F7快捷键就给带过了。其实这个环节非常重要，如果你非常了解这个环节，你开发源代码就会更加自信和清醒，而不是迷迷糊糊，摸棱两可…… 下图直观描述了从源代码到计算机执行完毕的各个大环节： 内容实在多，图上没位置了，这里就继续说明上图。上图的1234是几个大步骤。1是我们的开发环境，你的代码就是在这个平台上书写、调试、编译、执行。。。等等 上图2是我们在1中开发的
C++ 06 之 c++增强
LSG_Down的博客
06-12 191
c06c++增强.cpp。c06c++增强.cpp。
【C++提高编程-06】----C++之STL-函数对象、谓词、仿函数
一伦明悦的博客
06-16 662
在C++中，STL（Standard Template Library）中的函数对象（function object）、谓词（predicate）和仿函数（functor）是关键概念，用于实现通用算法的灵活性和可定制性。
C++ 22 之 立方体案例
LSG_Down的博客
06-13 183
c22立方体案例.cpp。
c++类与对象
05-30
C++中的类是一种用户自定义的数据类型，它允许将数据和函数组合在一起，形成一个逻辑上独立的实体。对象是类的一个实例，它可以使用类中定义的函数和变量，其中变量被称为对象的属性，函数被称为对象的方法。在C++中，使用类和对象可以实现面向对象编程的思想，使程序更加模块化、可维护和易扩展。 下面是一个简单的C++类的示例： ```c++ class Person { private: string name; int age; public: void setName(string n) { name = n; } void setAge(int a) { age = a; } string getName() { return name; } int getAge() { return age; } }; int main() { Person p; p.setName("Tom"); p.setAge(18); cout << "Name: " << p.getName() << endl; cout << "Age: " << p.getAge() << endl; return 0; } ``` 上面的代码定义了一个名为Person的类，它有两个私有属性name和age，以及四个公有方法setName、setAge、getName和getAge。在main函数中，创建了一个Person对象p，并通过对象的方法设置了其属性，最后输出了对象的属性值。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值