大话C++类与对象（二）

最新推荐文章于 2022-07-18 18:21:48 发布
最新推荐文章于 2022-07-18 18:21:48 发布
阅读量270 收藏
点赞数
分类专栏： Are You OKay C/C++ 文章标签： c++ 析构函数 构造函数 类与对象 new与delete
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44631615/article/details/110313329
版权

缺省参数的成员函数

带默认参数的定义函数中默认参数从右向左填数，而在函数的使用时，参数从左到右传递，如下，默认b = 10，在函数调用a2.Set(20.0);中，20.0对应a的数值，故sum = 30

详细C++代码如下：

#include<bits/stdc++.h>
using namespace std;

class A{
	float x, y;
	public:
		float Sum(void)
		{
			return x + y;
		}
		void Set(float a, float b = 10.0)
		{
			x = a;
			y = b;
		}
		void Print()
		{
			cout << "x = " << x << '\t' << "y = " << y << endl;
		}
};

int main()
{
	A a1, a2;
	a1.Set(2.0, 4.0);
	cout << "a1:";
	a1.Print();
	cout << "a1.sum = " << a1.Sum() << endl;
	a2.Set(20.0);
	cout << "a2:";
	a2.Sum();	
	cout << "a2.sum = " << a2.Sum() << endl;
	return 0;
}

运行结果如下：
在这里插入图片描述

定义类的指针以及用指针调用对象

详细C++代码如下

#include<bits/stdc++.h>
using namespace std;

class A{
	float x, y;
	public:
		float Sum(void)
		{
			return x + y;
		}
	void Set(float a, float b)
	{
		x = a;
		y = b;
	}
	void Print()
	{
		cout << "x = " << x << '\t' << "y = " << y << endl;
	}
};

int main()
{
	A a1, a2;
	A *p;
	p = &a1;
	p->Set(2.0, 3.0);
	p->Print();
	cout << p->Sum() << endl;
	a2.Set(10.0, 20.1);
	a2.Print();
	return 0;
}

运行结果如下：
在这里插入图片描述

返回引用类型的成员函数（ 把引用作为返回值）

通过使用引用来替代指针，会使C++程序更容易阅读和维护。C++函数可以返回一个引用，方式与返回一个指针类似。当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。例如，请看下面这个简单的程序：

#include<iostream>
using namespace std;

int a[] = {2, 6, 8, 9, 10};
int & value(int i)
{
	return a[i];		//返回第i个元素的引用 
}

int main()
{
	int i;
	cout << "改变前的值：" << endl;
	for(i = 0; i < 5; i++)
	{
		cout << "a[" << i << "] = ";
		cout << a[i] << endl;
	}
	value(1) = 20;
	value(3) = 20;
	cout << "改变后的值：" << endl;
	for(i = 0; i < 5; i++)
	{
		cout << "a[" << i << "] = ";
		cout << a[i] << endl;
	} 
	return 0;
}

运行结果如下：
在这里插入图片描述
代码分析：
本例先定义一个全局的数组a，并初始化赋值。然后定义一个int型的引用函数value()，并且定义了一个整型的形参i，所以该函数的返回值也应该是引用类型的数据。在main()函数中，使用for循环，先遍历数组a。然后通过调用函数value()，修改数组a中的元素，并且返回第i个元素的引用。最后通过for循环再次变量数组a。

第二个类似的C++代码如下：

#include<iostream>
using namespace std;

class A{
	float x, y;
	public:
		float &Getx()
		{
			return x;		//返回x的引用 
		}
		void Set(float a, float b)
		{
			x = a;
			y = b;
		}
		void Print()
		{
			cout << x << '\t' << y << endl;
		}
};

int main()
{
	A a1, a2;
	a1.Set(3, 5);
	cout << "a1:";
	a1.Print();
	a1.Getx() = 30;		//向a1对象中的私有成员x赋值 
	cout << "\nchanged a1:";
	a1.Print();
	return 0;
}

运行结果如下：
在这里插入图片描述

构造函数与析构函数概述

由类得到对象，需要构造函数，系统会自动调用相应的构造函数；

对象使用完后需要释放占有的资源，系统就会自动调用相应的析构函数。

构造函数的定义

构造函数可以带参数（构造函数是在创建对象时，使用给定的值来将对象初始化）、可以重载，同时没有返回值。

构造函数是类的成员函数，系统约定构造函数名必须与类名相同。构造函数提供了初始化对象的一种简单的方法

Attention！！！
对构造函数，说明以下几点：

  • 1、构造函数的函数名必须与类名相同。构造函数的主要作用是完成初始化对象的数据成员以及其它的初始化工作。
  • 2、在定义构造函数时，不能指定函数返回值的类型，也不能指定为void类型。
  • 3、 一个类可以定义若干个构造函数。当定义多个构造函数时，必须满足函数重载的原则。
  • 4、构造函数可以指定参数的缺省值。
  • 5、若定义的类要说明该类的对象时，构造函数必须是公有的成员函数。如果定义的类仅用于派生其它类时，则可将构造函数定义为保护的成员函数。

由于构造函数属于类的成员函数，它对私有数据成员、保护的数据成员和公有的数据成员均能进行初始化。

Attentinon！！！
类的数据成员是不能在声明类时初始化的。
在这里插入图片描述
在这里插入图片描述
对局部对象，静态对象，全局对象的初始化：

  • 对于局部对象，每次定义对象时，都要调用构造函数。
  • 对于静态对象，是在首次定义对象时，调用构造函数的，且由于对象一直存在，只调用一次构造函数。
  • 对于全局对象，是在main函数执行之前调用构造函数的。

综合例子：

#include<iostream>
using namespace std;

class A{
	float x, y;
	public:
		A(float a, float b)
		{
			x = a;
			y = b;
			cout << "初始化局部对象" << endl;
		}
		A()
		{
			x = 0;
			y = 0;
			cout << "初始化静态局部对象" << endl;
		}
		A(float a)
		{
			x = a;
			y = 0;
			cout << "初始化全局对象" << endl;
		}
		void Print()
		{
			cout << x << '\t' << y << endl;
		}
};

A a0(100.0);				//初始化全局对象 
void f()
{
	cout << "进入f()函数" << endl;
	A a2(1, 2);
	static A a3; 			//a3静态对象 
}

int main()
{
	cout << "进入main函数" << endl;
	A a1(3.0, 7.0);			//初始化局部对象 
	f();					//进入f()函数，初局，初静 
	f();					//进入f()函数，初局
	return 0;
}

运行结果如下：
在这里插入图片描述

缺省的构造函数

在定义类时，若没有定义类的构造函数，则编译器自动产生一个缺省的构造函数，其格式为：className::className() { }

缺省的构造函数并不对所产生对象的数据成员赋初值；即新产生对象的数据成员的值是不确定的。

注：
关于缺省的构造函数，说明以下几点：

  • 1、在定义类时，只要显式定义了一个类的构造函数，则编译器就不产生缺省的构造函数
  • 2、所有的对象在定义时，必须调用构造函数
  • 3、在类中，若定义了没有参数的构造函数，或各参数均有缺省值的构造函数也称为缺省的构造函数，缺省的构造函数只能有一个
  • 4、产生对象时，系统必定要调用构造函数。所以任一对象的构造函数必须唯一

无参构造函数和全部参数都指定了默认值的构造函数，二者不可兼得

Box();
Box(int = 10, int = 10, int = 10);

在这里插入图片描述

构造函数与new运算符

可以使用new运算符来动态地建立对象。建立时自动调用构造函数，以便完成初始化对象的数据成员。最后返回这个动态对象的起始地址。

用new运算符产生的动态对象，在不再使用这种对象时，必须用delete运算符来释放对象所占用的存储空间。

示例C++代码如下：

#include<iostream>
using namespace std;

class A{
		float x, y;
	public:
		A(float a, float b)
		{
			x = a;
			y = b;
		}
		A()
		{
			x = 0;
			y = 0;
		}
		void Print()
		{
			cout << x << '\t' << y << endl;
		}
}; 

int main()
{
	A *p1, *p2;
	p1 = new A(3.1, 5.2);
	p2 = new A;
	p1->Print();
	p2->Print();
	delete p1;
	delete p2;
	return 0;
}

运行结果如下：
在这里插入图片描述

完成拷贝功能的构造函数

可以在定义一个对象的时候用另一个对象为其初始化，即构造函数的参数是另一个对象的引用，这种构造函数常为完成拷贝功能的构造函数。

完成拷贝功能的构造函数的一般格式为：
ClassName::ClassName(ClassName &<变量名>)
{ …
// 函数体完成对应数据成员的赋值
}

示例C++代码如下：

#include<iostream>
using namespace std;

class A{
		float x, y;
	public:
		A(float a = 0, float b = 0)
		{
			x = a;
			y = b;
		}
		A(A &a)
		{
			x = a.x;
			y = a.y;
		}
		void Print()
		{
			cout << x << '\t' << y << endl;
		}
};

int main()
{
	A a1(1.2, 3.3);
	A a2(a1);
	a2.Print();
	return 0;
}

运行结果如下：
在这里插入图片描述

隐含的完成拷贝功能的构造函数

如果没有定义完成拷贝功能的构造函数，编译器自动生成一个隐含的完成拷贝功能的构造函数，依次完成类中对应数据成员的拷贝。

由编译器为每个类产生的这种隐含的完成拷贝功能的构造函数，依次完成类中对应数据成员的拷贝。
在这里插入图片描述
示例C++代码如下：

#include<iostream>
using namespace std;

class A{
		float x, y;
	public:
		A(float a = 0, float b = 0)
		{
			x = a;
			y = b;
			cout << "调用了构造函数" << endl;
		}
		void Print()
		{
			cout << x << '\t' << y << endl;
		}
		~A()
		{
			cout << "调用了析构函数" << endl;
		}
};

int main()
{
	A a1(1.2, 2.3);
	A a2(a1);
	A a3 = a1;
	a1.Print();
	a2.Print();
	a3.Print();
	return 0;
}

运行结果如下：
在这里插入图片描述
当类中的数据成员中使用new运算符，动态地申请存储空间进行赋初值时，必须在类中显式地定义一个完成拷贝功能的构造函数，以便正确实现数据成员的复制。

示例C++的A代码如下：

#include<bits/stdc++.h>
using namespace std;

class Str{
		int Length;
		char *Sp;
	public:
		Str(char *string)
		{
			if(string)
			{
				Length = strlen(string);
				Sp = new char[Length + 1];
				strcpy(Sp, string);
			}
			else
				Sp = 0;
		}	
		void Show()
		{
			cout << Sp << endl;
		}
		~Str()
		{
			if(Sp)
				delete []Sp; 
		} 
};

int main()
{
	Str s1("Study C++");
	Str s2(s1);
	s1.Show();
	s2.Show();
	return 0;
}

运行结果如下：
在这里插入图片描述
代码分析如下：
在这里插入图片描述
示例C++的B代码如下：

#include<bits/stdc++.h>
using namespace std;

class Str{
		int Length;
		char *Sp;
	public:
		Str(char *string)
		{
			if(string)
			{
				Length = strlen(string);
				Sp = new char[Length + 1];
				strcpy(Sp, string);
			}
			else
				Sp = 0;
		}
		Str(Str &s)
		{
			if(s.Sp)
			{
				Length = s.Length;
				Sp = new char[Length + 1];
				strcpy(Sp, s.Sp);
			}
			else
				Sp = 0;	
		}
		void Show()
		{
			cout << Sp << endl;
		}
		~Str()
		{
			if(Sp)
				delete []Sp; 
		} 
};

int main()
{
	Str s1("Study C++");
	Str s2(s1);
	s1.Show();
	s2.Show();
	return 0;
}

运行结果如下：
在这里插入图片描述
代码分析：
在这里插入图片描述
对比A、B两个代码，我们可以发现显示定义拷贝函数的优势

构造函数与对象成员

在这里插入图片描述
对类A的对象初始化的同时还要对其成员数据类B的对象进行初始化，所以，类A的构造函数中要调用类B的构造函数。

示例C++代码如下：

#include<iostream>
using namespace std;

class A{
		float x, y;
	public:
		A(int a, int b)
		{ 
			x = a;
			y = b;
		}
		void Show()
		{
			cout << "x = " << x << '\t' << "y = " << y << endl;
		}
};

class C{
		float z;
		A a1;			//组合 
	public:
		C(int a, int b, int c):a1(b, c)
		{
			z = a;
		}
		void Show()
		{
			cout << "z = " << z << endl;
			a1.Show();
		}
	
};

int main()
{
	C c1(1, 2, 3);
	c1.Show();
	return 0;
}

运行结果如下：
在这里插入图片描述
在这里插入图片描述
ClassName::ClassName(args):c1(args1),…,cn(agrsn)
{
… //对其它成员的初始化
}
初始化对象成员的参数（实参）可以是表达式，也可以仅对部分对象成员进行初始化。

示例C++代码如下：

#include<iostream>
using namespace std;

class A{
		float x, y;
	public:
		A(int a, int b)
		{
			x = a;
			y = b;
		}
		void Show()
		{
			cout << "x = " << x << '\t' << "y = " << y << endl;
		}
};

class B{
		float x1, y1;
	public:
		B(int a, int b)
		{
			x1 = a;
			y1 = b;
		}
		void Show()
		{
			cout << "x1 = " << x1 << '\t' << "y1 = " << y1 << endl; 
		}
};

class C{
		float z;
		A a1;
		B b1;
	public:
		C(int a, int b, int c, int d, int e):a1(a + b, c), b1(a, d)
		{
			z = e;
		} 
		void Show()
		{
			cout << "z = " << z << endl;
			a1.Show();
			b1.Show();
		}
};

int main()
{
	C c1(1, 2, 3, 4, 5);
	c1.Show();
	return 0;
}

运行结果如下：
在这里插入图片描述
对对象成员的构造函数的调用顺序取决于这些对象成员在类中说明的顺序，与它们在成员初始化列表中的顺序无关。

当建立类ClassName的对象时，先调用各个对象成员的构造函数，初始化相应的对象成员，然后才执行类ClassName的构造函数，初始化类ClassName中的其它成员。析构函数的调用顺序与构造函数正好相反。

示例C++代码如下：

#include<iostream>
using namespace std;

class A{
		float x;
	public:
		A(int a)
		{
			x = a;
			cout << "调用了A的构造函数" << endl;
		} 
		~A()
		{
			cout << "调用了A的析构函数" << endl;
		}
}; 

class B{
		float y;
	public:
		B(int a)
		{
			y = a;
			cout << "调用了B的构造函数" << endl;
		}
		~B()
		{
			cout << "调用了B的析构函数" << endl;
		}
};

class C{
		float z;
		B b1;
		A a1;
	public:
		C(int a, int b, int c):a1(a), b1(b)
		{
			z = c;
			cout << "调用了C的构造函数" << endl;
		}
		~C()
		{
			cout << "调用了C的析构函数" << endl;
		}
};

int main()
{
	C c1(1, 2, 3);
	return 0;
}

运行结果如下：
在这里插入图片描述

析构函数

析构函数的作用与构造函数正好相反，是在对象的生命期结束时，释放系统为对象所分配的空间，即撤消一个对象。

析构函数也是类的成员函数，定义析构函数的格式为：
ClassName::~ClassName( )
{
// 函数体;
}

析构函数的特点如下：

  • 1、析构函数是成员函数，函数体可写在类体内，也可写在类体外。
  • 2、析构函数是一个特殊的成员函数，函数名必须与类名相同，并在其前面加上字符“~”，以便和构造函数名相区别。
  • 3、析构函数不能带有任何参数，不能有返回值，不指定函数类型。
  • 4、一个类中，只能定义一个析构函数，析构函数不允许重载。
  • 5、析构函数是在撤消对象时由系统自动调用的。

示例C++代码如下：

#include<iostream>
using namespace std;

class A{
	float x, y;
	public:
		A(float a, float b)
		{
			x = a;
			y = b;
			cout << "调用非缺省的构造函数" << endl;
		}
		A()
		{
			x = 0;
			y = 0;
			cout << "调用缺省的构造函数" << endl;
		}
		~A()
		{
			cout << "调用析构函数" << endl; 
		}
		void Print()
		{
			cout << x << '\t' << y << endl;
		}
};

int main()
{
	A a1;
	A a2(3.2, 33.3);
	cout << "退出主函数" << endl;
	return 0; 
}

运行结果如下：
在这里插入图片描述
在程序的执行过程中，对象如果用new运算符开辟了空间，则在类中应该定义一个析构函数，并在析构函数中使用delete删除由new分配的内存空间。因为在撤消对象时，系统自动收回为对象所分配的存储空间，而不能自动收回由new分配的动态存储空间。

示例C++代码如下：

#include<bits/stdc++.h>
using namespace std;

class Str{
		char *Sp;
		int Len;
	public:
		Str(char *string)
		{
			if(string)
			{
				Len = strlen(string);
				Sp = new char[Len + 1];
				strcpy(Sp, string);
			}
			else 
				Sp = 0;
		}
		void Show()
		{
			cout << Sp << endl;
		}
		~Str()
		{
			if(Sp)
			{
				delete []Sp;
				cout << "释放对象回收空间" << endl;
			}
				
				
		}
};

int main()
{
	Str s1("Study C++");
	s1.Show();
	return 0;
}

运行结果如下：
在这里插入图片描述
在这里插入图片描述
对于用new运算符动态生成的对象，在产生对象时调用构造函数，只有使用delete运算符来释放对象时，才调用析构函数。若不使用delete来撤消动态生成的对象，程序结束时，对象仍存在，并占用相应的存储空间，即系统不能自动地调用析构函数来撤消动态生成的对象。

示例C++代码如下：

#include<iostream>
using namespace std;

class A{
		float x, y;
	public:
		A(float a, float b)
		{
			x = a;
			y = b;
			cout << "调用构造函数" << endl;
		}
		void Print()
		{
			cout << x << '\t' << y << endl;
		}
		~A()
		{
			cout << "调用了析构函数" << endl;
		}
};

int main()
{
	cout << "进入main()函数" << endl;
	A *p1;
	p1 = new A(3.1, 5.2);
	p1->Print();
	delete p1;
	cout << "退出main()函数" << endl;
	return 0;
}

运行结果如下：
在这里插入图片描述
下面的C++例子类似本文中关于构造函数的第一个C++例子，为了让大家对析构函数、构造函数有一个更好的理解
在这里插入图片描述
详细C++代码如下：

#include<iostream>
using namespace std;

class A{
		float x, y;
	public:
		A(float a, float b)
		{
			x = a;
			y = b;
			cout << "初始化自动局部对象" << endl; 
		}
		A()
		{
			x = 0;
			y = 0;
			cout << "初始化静态局部对象" << endl;
		}
		A(float a)
		{
			x = a;
			y = 0;
			cout << "初始化全局对象" << endl; 
		}
		~A()
		{
			cout << "调用析构函数" << x << endl;
		}
};
A a0(100.3);			//初始化全局变量 

void f()
{
	A ab(10.2, 20.3);
	static A a3;
}

int main()
{
	cout << "进入main函数" << endl;
	f();		//初始化自动局部对象,初始化静态局部对象,调用析构函数10.2 
	f();		//初始化自动局部对象,调用析构函数10.2,调用析构函数0 
	return 0;	//调用析构函数100.3 
}

运行结果如下：
在这里插入图片描述

动态构造及析构对象数组

在这里插入图片描述
示例C++代码如下：

#include<iostream>
using namespace std;

class A{
		float x, y;
	public:
		A(float a = 0, float b = 0)
		{
			x = a;
			y = b;
			cout << "调用了构造函数" << endl;
		}
		void Print()
		{
			cout << x << '\t' << y << endl;
		}
		~A()
		{
			cout << "调用了析构函数" << endl;
		}
};

int main()
{
	cout << "进入main()函数" << endl;
	A *p1;
	p1 = new A[3];
	cout << "\n完成开辟数组空间\n" << endl;
	delete []p1;
	cout << "退出main()函数" << endl;
	return 0;
}

运行结果如下：
在这里插入图片描述
若在类的定义中没有显式地定义析构函数时，则编译器自动地产生一个缺省的析构函数，其格式为：
ClassName::~ClassName() { };

要释放对象的数据成员中用new运算符分配的动态空间时，必须显式地定义析构函数

实现类型转换的构造函数

示例C++代码如下：

#include<iostream>
using namespace std;

class A{
		float x, y;
	public:
		A(float a, float b)
		{
			x = a;
			y = b;
			cout << "调用构造函数" << endl;
		}
	~A()
	{
		cout << "调用析构函数" << x << endl;
	}
	void Print()
	{
		cout << x << '\t' << y << endl;
	}
}; 

int main()
{
	A a1(1.2, 10.3);
	a1.Print();
	a1 = A(3.3, 30.3);	//产生临时对象，初始化并赋值后立即释放
	a1.Print();
	cout << "退出主函数" << endl;
	return 0;  
}

运行结果如下：
在这里插入图片描述
注：当构造函数只有一个参数时，可以用= 强制赋值

示例C++代码如下：

#include<iostream>
using namespace std;

class B{
		float x;
	public:
		B(float a)
		{
			x = a;
			cout << "调用构造函数" << endl;
		}
		~B()
		{
			cout << "调用析构函数" << x << endl;
		}
		void Print()
		{
			cout << x << endl;
		}
};

int main()
{
	B b1(1.3);
	b1.Print();
	B b2 = 100;			
	b2.Print();
	b1 = 10;			//单参数可以这样赋值相当于b1 = B(10) 
	b1.Print();
	cout << "退出主函数" << endl;
	return 0;
}

运行结果如下：
在这里插入图片描述

之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！

源代码•宸
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[C++]类和对象（三）
三月，有人呼唤你的名字
12-09 631
构造函数与new运算符 ·以使用new运算符来动态地建立对象。建立时要自动调用构造函数，以便完成初始化对象的数据成员。最后返回这个动态对象的起始地址。 ·用new运算符产生的动态对象，在不再使用这种对象时，必须用delete运算符来释放对象所占用的存储空间。 ·用new建立类的对象时，可以使用参数初始化动态空间。
C++编程（四）：类和对象
GeniusAng的博客
08-08 374
C++：类和对象
C++初阶 —— 类与对象(一)
NapoleonCoder的博客
10-23 390
类和对象！
c++类 封装cjson_C++基础知识（三）-类和对象
weixin_39581099的博客
12-16 296
整理码字不易，养成好习惯，点赞关注，你的支持就是我写下去的动力，谢谢老板。本文为C++第三篇后续接着这篇文章写，大家可以持续关注，前两篇在主页4. 类和对象4.1 类和对象的基本概念4.1.1 C和C++中struct区别c语言struct只有变量c++语言struct 既有变量，也有函数4.1.2 类的封装我们编写程序的目的是为了解决现实中的问题，而这些问题的构成都是由各种事物组成，我们在计算机...
C++类与对象：拷贝构造函数&浅拷贝
qq_45481606的博客
07-14 1513
拷贝构造函数
大话模式中的Stategy模式用C++改写
01-20
《大话模式》是一本经典的面向对象设计模式的书籍，其中介绍了多种设计模式，包括Strategy模式。Strategy模式是一种行为设计模式，它使你能在运行时改变对象的行为。在这个模式中，一个类的行为或其算法可以在运行时...
大话西游2与梦幻西游的地图提取器(包含遮挡图),C++完整源码
04-02
这个名为“大话西游2与梦幻西游的地图提取器(包含遮挡图)”的项目，是使用C++编程语言编写的控制台应用程序，专用于从这两款知名网络游戏——大话西游2和梦幻西游中提取地图资源。下面将详细介绍这个项目所涉及的...
算法与数据结构c与c++描述
03-12
C++作为C的扩展，引入了面向对象编程（OOP）的概念，如类、对象、继承、多态等，这使得数据结构的实现更为封装和抽象。例如，使用类可以更好地模拟现实世界中的对象，如定义一个栈类，包含数据成员（如底指针）和...
VC++版大话西游搞笑周星弛.zip.zip
最新发布
09-19
源代码分析可以帮助我们理解如何使用C++实现了电影中的搞笑场景，以及项目中可能涉及到的编程概念和技术，如类的设计、面向对象编程、事件驱动编程、多媒体处理等。文本文件则可能揭示项目背后的故事，开发者的意图...
完整版大话练法.e.rar
04-02
《大话练法.e》是一本专注于编程技能修炼与提升的书籍，其电子版以rar压缩格式提供。这本书可能是为了帮助读者系统地学习和实践编程技术，提高编程能力，特别是对于初学者或有一定基础的程序员来说，是进一步提升...
C++动态组类，一个类中含有另一个类的对象,对象指针等
棒棒的博客
04-12 1397
详情看每句的注释！！ #include <iostream> using namespace std; class Point { public: Point() :x(0), y(0) { cout << "调用无参默认构造函数" << endl; } Point(int x1, int y1) :x(x1), y(y1) { cout << ...
【每日一练】day(12)
Pass-by
05-02 1172
文章目录 构造函数可以是虚函数吗？答：不能，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
C++ 题目（一）
胜利者的经验并不复杂,那就是寻找人生的关键点,并在关键时刻竭尽全力
08-16 1003
题目（一）求输出结果 #include using namespace std; struct Point3D { int x; int y; int z; }; int main () { Point3D *pPoint = NULL; int offset = (int) (&(pPoint)->z); printf ("%d", o
C++实验03(03)组合类：Triangle类与Point类
多学习
04-25 8722
题目描述 定义一个平面坐标系下的点类Point，有整型数据成员x,y坐标值。成员函数包括：（1）带默认值的构造函数，默认值均为0；（2）拷贝构造函数；（3）置x,y坐标值；（4）取x,y的坐标值，参数为两个整型量的引用，分别用于获取x,y坐标值。（5）输出函数，用于输出x,y坐标值。（6）求两个点之间距离的函数，参数是Point类的对象引用。 定义一个平面坐标系下的三角形类Triangle，数据成...
C++ 当类的构造函数中使用new关键字时，注意使用复制（拷贝）构造函数，进行深复制
weixin_43335392的博客
02-27 1008
所谓深复制，通俗的解释就是：不仅仅是复制数据的地址，更要复制数据本身 先来看一个不完善的类,如下： #include<iostream> #include<string> using namespace std; class StringBad { private: char *str;//指向字符串的指针 int len;//当前字符串的长度 static int ...
C++ Primer Plus第十二章摘要
stella_wy的博客
09-06 155
第十二章 类和动态内存分配 对类成员使用动态内存分配 隐式和显式复制构造函数 隐式和显式重载赋值运算符 在构造函数中使用new所必须完成的工作 使用静态类成员 将定位new运算符用于对象 使用指向对象的指针 实现队列抽象数据类型 1.静态成员有一个特点，无论创建了多少个对象，程序都只创建一个静态类变量副本，类的所有对象共享同一个静态成员。 2.不能在类声明中初始化静态成员变量，这是因为声明描述了如何分配内存，但并不分配内存。 这是因为静态类成员是单独存储的，而...
C++类和对象
wh22141334的博客
07-18 3973
c++中的类和对象
JavaScript权威指南（第6版） --- 自学笔记（20） --- 对象和数组的初始化表达式、属性访问表达式
u011744300的专栏
05-21 1771
对象和数组初始化表达式 实际上是一个新创建的对象和数组。有时也称对象直接量和数组直接量，但它们不是原始表达式，因为它们所包含的成员或者元素都是子表达式。 数组初始化表达式是通过一对方括号和其内部由逗号隔开的列表构成，初始化的结果是一个新创建的数组，数组的元素是逗号分隔的表达式的值。并且，数组初始化表达式中的元素初始化表达式也可以是数组的初始化表达式，也就是说，这些表达式是可以嵌套的。 []...
C++语言学习（四）——类与对象
m0_43426943的博客
08-02 266
C++语言学习（四）——类与对象一、构造函数（constructor）二、拷贝构造函数（copy constructor）三、析构函数（destructor）四、this指针五、赋值操作符重载六、函数与类对象七、栈和堆上的对象和对象数组八、类成员函数的存储方式 文章来源：https://blog.51cto.com/9291927/2143145 一、构造函数（constructor） 1、构造函数简介 C++语言中，构造函数是与类名相同的特殊成员函数。 在类对象创建时，自动调用构造函数，完成类对象的初始化
面向对象设计模式探索：从C++到策略与迪米特法则
在《大话C++编程设计模式》中，作者首先通过一个历史故事引入了面向对象思想的重要性，将古代印刷术与现代编程中的可维护性和可复用性相类比，强调了代码设计的灵活性和重用性。面向对象编程的核心在于将问题领域中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值