O si tienes paciencia, espera unos 10 días. Tal vez seré libre.
Hay un problema con la pregunta 8. Si la función de clasificación es una función miembro, entonces el argumento debe ser una matriz, sin ningún argumento que especifique la longitud de la matriz. A menos que la función de clasificación se declare estática y también se declare una matriz estática de estudiante*, se puede rastrear cada objeto de la clase de estudiante y se pueden ordenar todos los objetos. No hagas esta pregunta todavía, pídele al profesor que la corrija.
¿Puedo sumar algunos puntos? Son sólo 50 puntos por escribir tanto. . . . . . . .
============================================ === =================================
Todos los programas han pasado el VC 6.0 prueba.
============================================ === =================================
1.
# incluir & ltmath.h & gt
# incluir & ltiostream.h & gt
forma de clase { public:virtual float area()= 0};
En forma de círculo: forma pública { int x, y; float r;
público: círculo(int xx, int yy, float rr)
{ x = xxy = yyr = rr }
Área flotante(){
Regresar float(3.14 * r * r }};
En forma de rectángulo: forma pública {
int x1, y1, x2, y2;
Público:
Rectángulo(int xx1, int yy1, int xx2, int yy2)
{ x 1 = xx1; y 1 = YY 1; x2 = xx2y2 = yy2}
Área flotante(){
Retorno flotante(ABS(x 1-x2) )* ABS(y 1-y2));}};
void main(){
círculo *pc=nuevo círculo(1, 2, 2);
rectángulo * pr = nuevo rectángulo (1, 2, 3, 4);
forma * pS[2]; pS[0]= pS[1]= pr; p>
for(int I = 0;i<2;i++)
{ cout & lt& ltpS[I]->area()<<endl}}
= ==================================================== =========================
2.
# incluir & ltiostream.h & gt
Categoría Bobina
{
Privada:
doble m_UnLead
Doble m_Lead
doble m_Total
Público:
coil()
{
m_un lead=0;
m_Lead = 0;
}
Bobina (doble m_UnLead, doble m_Lead)
{
Esto->m_Lead = m_Lead
Esto->m_UnLead = m_UnLead
}
Doble GetTotal()
{
m _ Total = 17.0 * m _ UnLead+16.0 * m _ Lead
Devolver m _ Total
}
};
void main()
{
Double UnLead, lead;
cout & lt& lt"Ingrese la cantidad de aceite sin plomo:"
CIN & gt;& gtUnLead
cout & lt& lt"Ingrese la cantidad de aceite de plomo:"
CIN >>Lead;
Aceite para bobinas (sin plomo, sin plomo);
cout & lt& lt"Los ingresos totales son:"
>
}
======================================= == =======================================
3.
# include & ltiostream.h & gt
de forma rectangular
{privado:
repisa flotante, juncia;
Público:
Rectángulo(){ }
Rectángulo(flotador l, flotante s)
{ repisa = l juncia = s; /p>
Área flotante()
{return ledge * sedge;}
Área agregada de espacio amigable (rectángulo y ampr1, rectángulo y rectángulo. R2);
};
void addarea(rectangle&r1, rectángulo y rectángulo.
r2)
{ cout & lt& lt"Área total:"
}
void main()
{Rectangle Rectl(3 , 2), Rect2(4, 3);
addarea(Rectl, rect 2
}
=========); = =================================================== = =================
4.
# incluir & ltiostream.h & gt
# incluir & ltmath.h & gt
Complejo de clase
{
Público:
Complejo(): _real(0), _imag ( 0) {}
Números plurales explícitos (doble r): _real(r), _imag(0) {}
Números plurales (doble r, doble i): _real( r) , _imag(i) {}
Complejo & operador += (const double & d)
{
_ real+= d;
Devolver * this
}
Complejo y operador +=(const Complejo & c)
{
_ real+ = c . _ real;
_ imag+= c . _ imag;
Devolver * this
}
Operador & complejo - = (const double & d)
{
_ real -= d;
Devolver * esto
}
Complejo & operador-=(const Complejo & c)
{
_ real-= c _ real;
_imag-= c. _imag;
Devolver * this
}
Operador complejo & amp * = (const double & d)
{
_ real * = d;
_ imag * = d
Devolver * esto
}
Complejo & operador * = (const Complex & c)
{
doble re = _ real
doble im = _ imag
_ real = re * c . _ real-im * c . _ imag;
_ imag = re * c . /p>
}
Complejo & operador/=(const double & d)
{
_ real/= d;
_ imag/= d;
Devolver * this
}
Complejo & operador/=(const Complejo & c)
{
doble re = _ real
doble im = _ imag
doble d = c . _ imag * c . _ imag;
_ real =(re *c._r
eal+im * c . _ imag)/d
_ imag = (im * c . _ real-re * c . _ imag)/d
Return * this;
}
Constante Conj() compleja
{
Devuelve un número complejo (_real, -_imag);
}
doble Real()const { return _ Real;}
doble Imag()const { return _Imag;}
void Real( const doble & amp; re){ _ real = re }
void Imag(const double & amp; im){ _ imag = im;}
Conjunto vacío (const double & ampre; , const double & ampim) { _ real = re _ imag = im}
double Modsq()const { return _ real * _ real+_ imag * _ imag;}
doble Mod()const { return sqrt(_ real * _ real+_ imag * _ imag);}
Privado:
doble _ real
double _ imag
};
Operador compuesto en línea + (const Complex & c)
{
Devuelve números complejos (c .Real(), c.Imag());
}
Operadores compuestos en línea. c)
{
Devolver números complejos (-c.Real(),-c.Imag());
}
Operador compuesto en línea + (const Complex & amp; c, const double & ampd)
{
Devuelve un número complejo (c.Real() + d, c.Imag() );
}
Operador compuesto en línea + (const double & amp; const Complex & ampc)
{
Devolver números complejos (d + c.Real(), c.Imag());
}
Operador compuesto en línea + (const Complex & c1, const Complex & ampc2 )
{
Devuelve complejo (c1. Real() + c2. Real(), c1. Imag() + c2. imag()
}
Operadores compuestos en línea. c, const double & ampd)
{
Devuelve un número complejo (c.Real() - d, c.Imag());
}
p>Operador compuesto en línea - (const double & const Complex & ampc)
{
Devuelve un número complejo (d - c.Real(), - c .Imag());
}
Operador compuesto en línea. c1, const Complex & ampc2)
{
Return Complex(c1.Real() - c2.Real(), c1.Imag() - c2.
imag());
}
Operador compuesto en línea*(const Complex & amp; c, const double & ampd)
{
return Complex(c.Real() * d, c . Imag()* d);
}
Operador compuesto en línea *(const double & amp ; const Complex & ampc)
{
return Complex(c.Real() * d, c.Imag()* d);
}
Operador compuesto en línea *(const Complex & c1, const Complex & ampc2)
{
Número real doble = c1. Real() * c2. Real()-c1. Imagen() * c2. imag();
doble imag = c1. Real() * c2. Imagen() + c1. Imagen() * c2. real();
return Complex(real, imag);
}
Operador complejo en línea/(const complex & ampc, const double & ampd )
{
Devuelve un número complejo (c.Real()/d, c.Imag()/d);
}
Operador compuesto en línea/(const double & const Complex & ampc)
{
double DD = c . Real()* c Real()+c . Imag();
Devuelve un número complejo ((d * c.Real())/dd, (-d * c . Imag())/DD);
}
Operador complejo en línea/(const complex & ampc1, const complex & ampc2)
{
Doble d = c2. Real() * c2. verdadero() + c2. Imagen() * c2. imag();
Número real doble = (c1. Real() * c2. Real() + c1. Imag() * c2. imag())/d; doble imagen = (c1.Imag() * c2.Real() - c1.Real() * c2.
imag())/d;
return Complex(real, imag);
}
Número real doble incrustado (complejo constante y ampc)
p>{
Regresar c . Real();
}
Imagen doble incrustada (const complex & ampc)
{
Regresar c . Imag();
}
ABS dual en línea (const Complex & amp; c)
{
Regresar sqrt(c . Real()* c . Real()+c . Imag()* c . Imag());
}
Binorm integrado (const Complex y ampc)
{
Devuelve c . Real()* c . Real()+c Imag(). ;
}
Conj complejo en línea(const Complex & amp; c)
{
Devuelve un número complejo (c.Real ( ), -c .Imag());
}
oyster&;operator<(ostream&operator, const complex&c)
{
os & lt& ltc . Real()& lt;& lt"+" & lt;& ltc .& lt;& lt"I";
Volver al sistema operativo;
int main()
{
Complejo a(1, 2), b, c;
c = a +b;
cout & lt& ltc & lt& ltendl
c = a-b;
cout & lt& ltc & lt& ltendl
Regresar 0;
}
====================== =========== ======================================= =====
5.
# include & ltiostream.h & gt
# include & ltmath.h & gt
Punto t de clase
{
Privado:
int x, y;
Público:
punto de ajuste vacío (int m, int n); /p>
movimiento vacío (int xoffset, int yoffset);
tpoint (int m, int n
int getx();
Amigo doble distancia (tpunto a, t punto b);
};
int tpoint::getx()
{
Devolver x;
}
int tpoint::gety()
{
Devuelve y;
}
tpoint::tpoint(int m, int n)
{
x = m ;
y = n;
}
punto tvoid::punto de ajuste (int m, int n )
{
x = m;
y = n;
}
punto vacío:: mover(int xoffset, int yoffset)<
/p>
{
x+= xoffset;
y+= yoffset;
}
Distancia doble (punto t a , t punto b)
{
int k, l;
k = a x-b . y-b . y;
Return sqrt(k * k+l * l);
}
void main()
. {
punto a(3, 4), b(6, 8);
punto p(5, 6);
p.move (5); , 4);
int m, n;
m = p .
p>
doble d = distancia(a,b);
cout<<"la distancia es"<<d;
cout<<\n las regulaciones xc de p son: "& lt& ltm;
cout & lt& lt\ n Las coordenadas de p son: "& lt& ltn & lt& lt"\ n";
}
= ================================================== = ==========================
6.
# incluir & ltiostream.h & gt
Sandía {
Privado:
Peso flotante;
Total flotante estático;
Total int estático
Público:
Sandía (w flotante)
{ peso = w;
total w+=peso;
total n++;
}
~Sandía()
{ total w-=peso;
total n- ;
}
visualización vacía();
disp total vacío estático();
};
sandía flotante ::totalw = 0;
int sandía::total n = 0;
void sandía::display()
{ cout & lt& lt"El el peso de la sandía es: ";
cout & lt& ltweight& lt& lt\ n ';
}
void sandía::totaldisp()
{ cout & lt& lt"El peso total es:";
cout & lt& lttotalw & lt& lt\ n ';
cout & lt& lt"El peso total es: ";
cout & lt& lttotaln & lt& ltendl
}
void main(){
水瓜w 1(3.5) ;
w 1. display();
Sandía::total disp();
Sandía w2(6);
w2 . display();
Sandía::total disp();
Sandía w3(6);
w3 .display();
p>
Sandía::total disp();
w2.Sandía::~sandía();
Sandía::total disp();
}
=================================
==============================================
7.
# include & ltiostream.h & gt
const float PI =(float)3.1415926;
void main()
{
int iType
Radio flotante, a, b, área;
cout & lt& lt"¿Qué tipo de gráfico es? (1 - Círculo 2-Rectángulo 3-Cuadrado): ";
CIN>>iType
Interruptor (Tipo)
{
Caso 1 :
cout<<"El radio del círculo es:";
CIN>>radius;
Área = PI *radio* Radio;
cout & lt& ltEl área es: "< & ltarea & lt& ltendl
Descanso;
Caso 2:
cout & lt& lt"La longitud de el rectángulo es: ";
CIN & gt;& gta;
cout & lt& ltEl ancho del rectángulo es: ";
CIN & gt; & gtb;
cout & lt& ltEl área es: "< & ltarea & lt& ltendl
Descanso;
Caso 3:
cout & lt& lt"La longitud del lado del cuadrado es";
CIN & gt;& gta;
Área = a * a
cout & lt& ltEl área es: "< & ltarea & lt& ltendl
Break;
Valor predeterminado:
cout & lt& lt" no es legal ¡Ingrese el valor "&! lt& ltendl
}
}
==================== ===== ============================================== ===== =
8.
Algo anda mal
==================== === ================================================ === ====
9.# include & ltiostream.h & gt
Pila de clases
{
privado: int base[ 10];
public:int size;
STACK();
Push no válido (entero a)
{
base[tamaño++]= a;
}
int p()
{
Devuelve base [-tamaño ];
}
};
PILA::PILA(){ tamaño = 0;};
int main()
{
Pila s;
cout & lt& lt"pop"< & ltendl
s . /p>
s .empujar(2);
s . push(3);
cout & lt& lts .
lt;& ltendl
cout & lt& lts . p()& lt;& ltendl
cout & lt& lts . >cout & lt& lts .p()& lt;& ltendl
Devuelve 0;
}
============ ==================================================== ===============
10.
# incluir & ltiostream.h & gt
# incluir & ltiomanip .h & gt
Personas de clase
{
int número;
Nombre del personaje[10];
public:void input()
{
cout & lt& lt "No es posible": CIN & gt; & gtNo; Nombre:";CIN>>Name;
}
Visualización no válida()
{
cout <& lt"No.
"
cout & lt& lt"Nombre:"
}
};
Alumnos de la clase: figuras públicas
{
privado:char departamento[6];
público:void input()
{
persona::entrada ();
cout & lt& lt"Número de clase:"; CIN & gt; & gtDeparture;
}
Visualización no válida ()
{
persona::disp();
cout & lt& lt"Número de categoría:"
}
} ;
Profesor de la clase: figura pública
{
privado:char departamento[10];
público:void input()
{
persona::entrada();
cout & lt& lt"Departamento:"; CIN & gt & gtSalida;
}
Visualización no válida()
{
persona::disp();
cout & lt& lt"Departamento: "
}
};
void main()
{
Estudiante s 1;
p>
Profesor t 1;
cout & lt& lt"Ingrese los datos de un estudiante:\n"; lt& lt"Ingresar datos del profesor:\n" t 1
cout & lt& lt" Mostrar datos de un estudiante:\n" s 1 . >cout <<"Mostrar datos del profesor:\n";t 1. disp();
}
================= ==================================================== ==========
11.
========================= ==================================================== ==
12.