PROGRAMA 6:

#include <stdio.h>
#include <iostream>
#include <math.h>
#include <conio.h>
#include <stdlib.h>
void circulo();
void rectangulo ();
void triangulo ();
void menu ();
int main()
{
 menu();
}
void menu ()
{
 int a;
 printf ("\n 1.Circulo");
 printf ("\n 2.rectangulo");
 printf ("\n 3.triangulo");
 printf ("\n Elige una opcion: ");
 scanf ("%d",&a);
 
 switch (a)
 {
  case 1:
   circulo();
   break;
  case 2:
   rectangulo();
   break;
  case 3:
   triangulo();
   break;
   default:
    printf ("\n\n\t\tser humano o ser estraterrentre opcion incorrecta");
      
 }
}
void circulo ()
{   int radio,area;
 scanf ("%d",&radio);
 area=(3.1416*radio*radio);
 printf ("resultado es:",area);
}
void rectangulo ()
{   int b,h,area;
 scanf ("%d",&b);
 scanf ("%d",&h);
 area=(b*h);
 printf ("resultado es:",area);
}
void triangulo ()
{   int b,h,area;
 scanf ("%d",&b);
 scanf ("%d",&h);
 area=(b*h/2);
 printf ("resultado es:",area);
}

PROGRAMA 5:

#include <stdio.h>
#include <iostream>
#include <math.h>
#include <conio.h>
#include <stdlib.h>
void area_triangulo ();
void area_circulo();
void area_cuadrado();
void area_rectangulo ();
void cubo();
void cilindro();
int main ()
{
 area_triangulo();
 area_circulo();
 area_cuadrado();
 area_rectangulo();
 cubo();
 cilindro();
 printf ("Adios Tontos");
 return 0;
}
void area_triangulo()
{
 float area,b,h;
 scanf ("%d",&b);
 scanf ("%d",&h);
 area=(b*h)/2;
 printf ("area es:",area);
}
void area_circulo()
{
 float area,b,c;
 scanf ("%d",&b);
 c=(b*b);
 area=(c*3.1416);
 printf ("area es:",area);
}
void area_cuadrado ()
{
 float area,b;
 scanf ("%d",&b);
 area=(b*b);
 printf ("area es:",area);
}
void area_rectangulo()
{
 float area,b,c;
 scanf ("%d",&b);
 scanf ("%d",&c);
 area=(b*c);
 printf ("area es:",area);
}
void cubo()
{
 float volumen,a;
 scanf ("%d",&a);
 volumen=(a*a*a);
 printf ("el volumen es:",volumen);
}
void cilindro()
{
 float volumen,radio,altura;
 scanf("%f", &radio);
 scanf("%f", &altura);
    volumen= (3.1416*radio*radio*altura);
    printf ("el volumen es:",volumen);
}

PROGRAMA 3:

#include <stdio.h>
#include <iostream>
#include <conio.h>
#include <math.h>
int main ()
{
 int edad;
 cout<<"ingresa ru edad:";
 cin>>edad;
 
 if (edad>=1 && edad<=2)
 {
  cout<<"guarderia";
 }
 if (edad>=3 && edad<=5)
 {
  cout<<"kinder";
 }
 if (edad>=6 && edad<=11)
 {
  cout<<"primaria";
 }
 if (edad>=12 && edad<=14)
 {
  cout<<"secundaria";
 }
 if (edad>=15 && edad<=17)
 {
  cout<<"preparatoria";
 }
 if (edad>=18 && edad<=23)
 {
  cout<<"licenciatura";
 }
 if (edad>=24 && edad<=45)
 {
  cout<<"maestria";
 }
 if (edad>45)
 {
  cout<<"doctorado";
 }
 return 0;
}

PROGRAMA 2:

#include <stdio.h>
#include <iostream>
#include <math.h>
#include <conio.h>
int main()
{
 int a,b,c;
 cout<<"ingresa un numero";
 cin>>a;
 cout<<"ingresa un numero";
 cin>>b;
 if (a>b)
 {
  cout<<"el numero mayor es:"<<a;
 }
 if else
 {
  cout<<"el numero menor es:"<<a;
 }
 if (b>a)
 {
  cout<<"el numero mayor es:"<<b;
 }
 if else
 {
  cout<<"el numero menor es:"<<b ;
 }
 return 0;
 getch();
}

 PROGRAMA 1:

#include <stdio.h>

int main ()

{

int a,b,suma;

cout <<"ingresa un numero";

cin>>a;

cout<<"ingresa un nmero"

cin >>b;

suma=(a+b);

cout <<"el resultado es"<<suma;

return 0;

}

¿QUE ES  UN CONSTRUCTOR?

un constructor es una subrutina cuya misión es inicializar un objeto de una clase. En el constructor se asignan los valores iniciales del nuevo objeto.

Se utiliza para crear tablas de clases virtuales y poder así desarrollar el polimorfismo, una de las herramientas de la programación orientada a objetos. Al utilizar un constructor, el compilador determina cual de los objetos va a responder al mensaje (virtual) que hemos creado. Tiene un tipo de acceso, un nombre y un paréntesis.

Ejemplo en C++

#include <iostream>
using std::cout;
using std::endl;
#include <new>
class Prueba
{
public:
Prueba(int numero = 0); //constructor.
~Prueba(); //destructor
private:
int x;
};
//definiciones de las funciones miembro
Prueba::Prueba(int numero)//constructor.
{
x = numero;
cout << "Se ejecuta el constructor del objeto nro: " << (*this).x << endl;
}
Prueba::~Prueba()
{
cout << "Se ejecuta el DESTRUCTOR del objeto nro: " << (*this).x << endl;
}
int main()
{
cout << "***Entramos a main" << endl;
Prueba objeto(0);
{
cout << "***Entramos al bloque" << endl;
Prueba objetoA(1);
Prueba objetoB(2);
cout << "***Salimos del bloque" << endl;
}
Prueba *ptr; //creamos un puntero.
ptr = new Prueba(3);//le asignamos un objeto dinamicamente, con argumento 3.
Prueba *ptr2;
ptr2 = new Prueba(4);//segundo puntero.
//AHORA LIBERAMOS LA MEMORIA DINAMICA QUE HABIAMOS SOLICITADO, USANDO DELETE.
cout << "--Borramos ptr2" << endl;
delete ptr2;
cout << "--Borramos ptr" << endl;
delete ptr;
cout << "***Ahora estamos por salir de main(), al salir se ejecutara el destructor" << endl << "del objeto 0 creado al principio de main()" << endl;
return 0;
}
g++ destructores.cpp -o destructores.out

¿QUE ES DESTRUCTOR?

Un destructor en programación orientada a objetos es una función miembro especial llamadas automáticamente en la ejecución del programa, y por tanto no tienen por qué ser llamadas explícitamente por el programador. Sus principales cometidos son:

• liberar los recursos computacionales que el objeto de dicha clase haya adquirido en su tiempo de ejecución al expirar éste.
• quitar los vínculos que pudiesen tener otros recursos u objetos con éste.

Los destructores son invocados automáticamente al alcanzar el flujo del programa el fin del ámbito en el que está declarado el objeto.

Ejemplo en C++

#include <iostream>
#include <string>
 
class foo
{
 public:
 
 foo( void )
 { 
  print( "foo()" );
 } 
 
 ~foo( void )
 { 
  print( "~foo()" );
 }
 
 void print( std::string const& text ) 
 {
  std::cout << static_cast< void* >( this ) << " : " << text << std::endl;
 }
 
/* 
 Deshabilitado el contructor de copia y el operador de asignación al hacerlos privados
*/ 
 private:
 
 foo( foo const& );
 
 foo& operator = ( foo const& );
};
 
int main( void )
{
 foo array[ 3 ];
/* 
 Cuanto la 'main' termina, el destructor es invocado para cada elemento de 'array'.
 La primera instancia creada es la última en ser destruída.
*/
}