高分求高手帮忙编写一个c++程序，急急

2024-12-01 18:52:29

推荐回答（3个）

回答1：

专业的我给你最全面的解答，请额外加分！！！全部实践加理论！！！用5个文件，把vs打开，.h的文件全放到.h底下，.cpp文件全放在.cpp底下！！！执行即可！！！下面是这些文件的代码，不能改文件名！！！

//C3DBasic.h
#ifndef C3DBasic_H_
#define _C3DBasic_H_
#pragma once
class C3DBasic
{
protected:
//属性定义
//保护成员，protected含义是在自己内部是private，继承的子孙和自己可以访问，外界不能访问
//如果是private含义是仅自己可见，不会继承给子孙;若是public则大家都可见
int X;
int Y;
int Z;
public:
C3DBasic(void);//构造函数
C3DBasic(int x,int y,int z);//带参纳漏改数构造函数
C3DBasic(C3DBasic &obj);//拷贝构造函数
C3DBasic operator=(C3DBasic &obj);//赋值运算符重载，也属于拷贝构造
~C3DBasic(void);//析构函数
};
#endif

//C3DPoint.h
#ifndef _C3DPoint_H_
#define _C3DPoint_H_
#pragma once
#include "c3dbasic.h"
class C3DPoint :
private C3DBasic
//何为继承：继承就是把父类中除了养老金（个人财产）private外，
//其他的慈善捐款public（谁说子孙不能拿？子孙是法定继承人，不捐了，红十字会太黑了）
//和给子孙的的遗产protected（外界不能访问，只有子孙可以，这难道不是遗产吗）拿给子类使用
//结束了吗？没有，还要看孩子怎么用这笔钱！
//何为使用：private继承——全部是我的私有财搜誉产！！！跟父类中的private性质一样
//public：充公！自己外界都可用！跟父类中的public一样！
//protected：做遗产，自己及子孙都可用！跟父类中的public一样！
//这里只展示private
{
private://我自己打工挣的钱！新属性
int H;
public://花出去的
C3DPoint(void);//构造函数，他会默认调用父类的，有爸才有我
C3DPoint(int x,int y,int z,int h);//带参数的构造函数，默认会调用父类的带参构造
C3DPoint(C3DPoint &obj);//拷贝构造函数
C3DPoint operator=(C3DPoint &obj);//赋值运算符重载，也属于拷贝构造
~C3DPoint(void);//析构函数，默认先调用子类，再调用父类的
};
#endif

//C3DBasic.cpp
#include "C3DBasic.h"
#include
using namespace std;

C3DBasic::C3DBasic(void)//构造函数
{
cout<<"调用构造函数C3DBasic()...\n";
}

C3DBasic::C3DBasic(int x,int y,int z)//带参数构造函数
{
cout<<"调用带参数构造函数C3DBasic(int x,int y,int z)...\n";
X=x,Y=y,Z=z;
cout<<"构造结果: X="<}

C3DBasic::C3DBasic(C3DBasic &obj)//拷贝构造函数,&是引用不是取地址
{
cout<<"调用拷贝构造函数C3DBasic(C3DBasic &obj)...\n";
X=obj.X,Y=obj.Y,Z=obj.Z;
cout<<"构造结果: X="<}

C3DBasic C3DBasic::operator=(C3DBasic &obj)//赋值运算符重载，也属于拷贝构造
{
cout<<"用=进行拷贝构造...\n";
this->洞判X=obj.X;
this->Y=obj.Y;
this->Z=obj.Z;
return *this;
}

C3DBasic::~C3DBasic(void)
{
cout<<"调用析构函数~C3DBasic()...\n";
}

//C3DPoint.cpp
#include "C3DPoint.h"
#include
using namespace std;

C3DPoint::C3DPoint(void)//":C3DBasic(void)"里面的这里加不加一样的
//构造函数，他会默认调用父类的，有爸才有我
{
cout<<"调用构造函数C3DPoint()...\n";
}

C3DPoint::C3DPoint(int x,int y,int z,int h)//":C3DBasic(int x,int y,int z)"
//带参数的构造函数，默认会调用父类的带参构造
{
cout<<"调用带参数构造函数C3DPoint(int x,int y,int z,int h)...\n";
X=x,Y=y,Z=z,H=h;
cout<<"构造结果: X="<}

C3DPoint::C3DPoint(C3DPoint &obj)
{
cout<<"调用拷贝构造函数C3DPoint(C3DPoint &obj)...\n";
X=obj.X,Y=obj.Y,Z=obj.Z,H=obj.H;
cout<<"构造结果: X="<}

C3DPoint C3DPoint::operator=(C3DPoint &obj)//赋值运算符重载，也属于拷贝构造
{
cout<<"用=进行拷贝构造...\n";
this->X=obj.X;
this->Y=obj.Y;
this->Z=obj.Z;
this->H=obj.H;
return *this;
}

C3DPoint::~C3DPoint(void)
//析构函数，默认先调用子类，再调用父类的
{
cout<<"调用析构函数~C3DPoint()...\n";
}

//main.cpp
#include"C3DBasic.h"
#include"C3DPoint.h"
#include
using namespace std;

//放在函数里面的目的，是为了让大家看到调用析构函数的结果
//析构函数只在对象销毁时被调用，如果对象建立在main里面，永远看不到析构的调用顺序

void funcPN()
{
cout<<"我们只执行C3DPoint A;，会发现...\n";
C3DPoint A;
system("pause");
}

void funcPNY()
{
cout<<"我们又只执行C3DPoint A;，会发现...\n";
C3DPoint A;
system("pause");
}

void funcBN()
{
cout<<"我们只执行C3DBasic A;，会发现...\n";
C3DBasic A;
system("pause");
}

void funcBNY()
{
cout<<"我们又只执行C3DBasic A;，会发现...\n";
C3DBasic A;
system("pause");
}

void funcBY()
{
cout<<"我们只执行C3DBasic A(3,4,5);，会发现...\n";
C3DBasic A(3,4,5);
system("pause");
}

void funcBYY()
{
cout<<"我们又只执行C3DBasic A(3,4,5);，会发现...\n";
C3DBasic A(3,4,5);
system("pause");
}

void funcPY()
{
cout<<"我们只执行C3DPoint A(3,4,5,6);，会发现...\n";
C3DPoint A(3,4,5,6);
system("pause");
}

void funcPYY()
{
cout<<"我们又只执行C3DPoint A(3,4,5,6);，会发现...\n";
C3DPoint A(3,4,5,6);
system("pause");
}

void funcPYE()
{
cout<<"倘若\nC3DPoint A(3,4,5,6),B;\nB=A;\n会发现...\n";
C3DPoint A(3,4,5,6),B;
B=A;
system("pause");
}

void funcPYK()
{
cout<<"倘若\nC3DPoint A(3,4,5,6);\nC3DPoint B(A);\n会发现...\n";
C3DPoint A(3,4,5,6);
C3DPoint B(A);
system("pause");
}

void funcBYE()
{
cout<<"倘若\nC3DBasic A(3,4,5),B;\nB=A;\n会发现...\n";
C3DBasic A(3,4,5),B;
B=A;
system("pause");
}

void funcBYK()
{
cout<<"倘若\nC3DBasic A(3,4,5);\nC3DBasic B(A);\n会发现...\n";
C3DBasic A(3,4,5);
C3DBasic B(A);
system("pause");
}

int main()
{
funcPN();
cout<<"\n\n\n";
funcPNY();
cout<<"\n\n\n";
funcBN();
cout<<"\n\n\n";
funcBNY();
cout<<"\n\n\n";
funcBY();
cout<<"\n\n\n";
funcBYY();
cout<<"\n\n\n";
funcPY();
cout<<"\n\n\n";
funcPYY();
cout<<"\n\n\n";
funcPYE();
cout<<"\n\n\n";
funcPYK();
cout<<"\n\n\n";
funcBYE();
cout<<"\n\n\n";
funcBYK();
cout<<"\n\n\n";
cout<<"现在看明白了吧，所有解释均在代码里...\n";
system("pause");
return 0;
}

/*
总结：什么是拷贝构造？
1.拷贝：COPY复制的意思。
2.构造：2种方法
{
1.用=号，由于=只能识别类型，所以当操作对象是类的时候，用户使用=时，系统会自动生成
默认的运算符重载函数，通过赋值的方式完成复制，那么对象的成员就由无到有的构造
出来了
2.用拷贝构造函数构造：不就是比构造函数多了2个字“拷贝”吗？那不过就是构造函数的重
载罢了，用户使用参数列表初始化的时候，系统会自动生成默认的以引用为参数的重载
构造函数，还是通过赋值的方式完成复制，那么对象的成员就由无到有的构造出来了
}
3.生命周期：派生类与父类的生命周期——你不感觉很像递归吗？
void fun(int n)//n派生次数，也是第几代孩子
{
if(n==0)//你老爸！
return;
else
fun(n-1);
}
于是出现：
调用 “老爸”构造函数...，老爸光荣诞生于世界
调用 “第一代孩子”构造函数...儿子从老爸那诞生了，神了！
如果在其中添加执行孩子成员函数的话，则执行孩子成员函数的话...
调用 “第一代孩子”析构函数...儿子完成任务
调用 “老爸”析构函数...用不到老爸了！
*/

回答2：

过段时间吧。现在忙着一考试。。这个很简单的。运樱你可培谨以自己尝旁中丛试着写。
你在构造函数或其它函数里面用输出语句输出表示当前的情况就OK了。

回答3：

class CTest
{
public:
CTest()
{
n=0;
}
CTest(int nParam)
{
n=nParam;
}
CTest(CTest &self)
{
n=self.n;
}
~CTest()
{
}
void SetValue(int nParam)
{
n=nParam;
}
private:
int n;
}

最新问答

综合百科中，哪个产生的历史最早

qq空间日志一般都写些什么好？有时候想写点东西给别人看，却又不知道写什么。

淘宝商城买普洱茶哪家的好？

现在电焊工一般月工资拿多少？

开具银行承兑汇票需要哪些东西？

哈站到南岗区中兴大道72号坐几路公交车有直达的公交车吗

沈阳北大营海鲜市场在哪

初学者求助 STC89C52单片机，不用外部中断的前提下，如何对外部信号处理。

已知函数y=f（x）在x=x0处的导数为11，则下图等于？求详细

求一本言情小说，男主之前对女主不好，后来男主眼睛失明且瘫痪，女主假扮护士，来照顾男主，