Diga si las instruciones de main son legales o ilegales y por que.

a.
#include <iostream>
using namespace std;
class base {
 int i, j;
public:
 void set(int a, int b) { i = a; j = b; }
 void mostrar() { cout << i << " " << j << "\n"; }
};
class derivada : public base {
 int k;
public:
 derivada(int x) { k = x; }
 void mostrar_k() { cout << k << "\n"; }
};
int main(){
 derivada obj(3);
 obj.set(1, 2);
 obj.mostrar();
 obj.mostrar_k();
 return 0;
}

b.
#include <iostream>
using namespace std;
class base {
 int i, j;
public:
 void set(int a, int b) { i = a; j = b; }
 void mostrar() { cout << i << " " << j << "\n"; }
};
class derivada : private base {
 int k;
public:
 derivada(int x) { k = x; }
 void mostrar_k() { cout << k << "\n"; }
};
int main(){
 derivada obj(3);
 obj.set(1, 2);
 obj.mostrar();
 return 0;
}

c.
include <iostream>
using namespace std;
class base {
protected:
 int i, j; 
public:
 void set(int a, int b) { i = a; j = b; }
 void mostrar() { cout << i << " " << j << "\n"; }
};
class derivada : public base {
 int k;
public:
 void setk() { k = i * j; }
 void mostrark() { cout << k << "\n"; }
};
int main(){
  derivada obj;
  obj.set(2, 3);
  obj.mostrar();
  obj.setk(); 
  obj.mostrark();
  return 0;
}

d.
#include <iostream>
using namespace std;
class base {
protected:
 int i, j;
public:
 void set(int a, int b) { i = a; j = b; }
 void mostrar() { cout << i << " " << j << "\n"; }
};
class derivada1 : public base {
 int k;
public:
 void setk() { k = i*j; } // legal
 void mostrark() { cout << k << "\n"; }
};
class derivada2 : public derivada1 {
int m;
public:
 void setm() { m = i-j; } // legal
 void mostrarm() { cout << m << "\n"; }
};
int main(){
 derivada1 obj1;
 derivada2 obj2;
 obj1.set(2, 3);
 obj1.mostrar();
 obj1.setk();
 obj1.mostrark();
 obj2.set(3, 4);
 obj2.mostrar();
 obj2.setk();
 obj2.setm();
 obj2.mostrark();
 obj2.mostrarm();
 return 0;
}

e.
#include <iostream>
using namespace std;
class base {
protected:
 int i, j;
public:
 void set(int a, int b) { i = a; j = b; }
 void mostrar() { cout << i << " " << j << "\n"; }
};
class derivada1 : private base {
 int k;
public:
 void setk() { k = i*j; }
 void mostrark() { cout << k << "\n"; }
};
class derivada2 : public derivada1 {
 int m;
public:
 setm() { m = j-i; } // error
 void mostrarm() { cout << m << "\n"; }
};
int main(){
  derivada1 obj1;
  derivada2 obj2;
  obj1.set(1, 2);
  obj1.mostrar();
  obj2.set(3, 4);
  obj2.mostrar();
  return 0;
}

f.
#include <iostream>
using namespace std;
class base {
 int i;
protected:
 int j;
public:
 int k;
 void seti(int a) { i = a; }
 int geti() { return i; }
};
class derivada : protected base {
public:
 void setj(int a) { j = a; };
 void setk(int a) { k = a; };

 int getj() { return j; }
 int getk() { return k; }
};
int main(){
  derivada obj;
  obj.seti(10);
  cout << obj.geti();
  obj.k = 10;
  obj.setk(10);
  cout << obj.getk() << " ";
  obj.setj(12);
  cout << obj.getj() << " ";
  return 0;
}

Diga si las siguientes definiciones de clase son válidas y por que y si las sentencias de main son legales o no y por que.

a.
#include <iostream>
using namespace std;
class base {
 int i;
public:
 int j, k;
 void seti(int x) { i = x; }
 int geti() { return i; }
};
class derivada : private base {
public:
  base::j;
  base::seti;
  base::geti;
 
  base::i;   // ilegal - no se puede elevar el acceso
 
  int a; // public
};
int main(){
  derivada obj;
  obj.i = 10;
  obj.j = 20;

  obj.k = 30;
  obj.a = 40;
  obj.seti(10);
  cout << obj.geti() << "  " << obj.j << " " << obj.a;
  return 0;
}

Corrija las instrucciones en main sin modificar las clases en el siguiente programa. otra forma de corregir es usando clases virtuales, use este método y explique como funciona.

#include <iostream>
using namespace std;
class base {
public:
  int i;
};
class derivada1 : public base {
public:
 int j;
};
class derivada2 : public base {
public:
 int k;
};
class derivada3 : public derivada1, public derivada2 {
public:
 int sum;
};
int main(){
  derivada3 obj;
  obj.i = 10;
  obj.j = 20;
  obj.k = 30;
  obj.sum = obj.i + obj.j + obj.k;
  cout << obj.i << " ";
  cout << obj.j << " " << obj.k << " ";
  cout << obj.sum;
  return 0;
}

En que caso las siguientes sentencias serían legales

clase_B *p; // puntero al objeto del tipo clase_B
clase_B objB // objeto del tipo clase_B
clase_D objD // objeto del tipo clase_D
p = &objB;
p = &objD;

Como modificaría la sentencia ilegal para que pudiera ser compilada?
Que mostrará esa sentencia y pòr que?

#include <iostream>
#include <cstring>
using namespace std;
class clase_B {
 char autor[80];
public:
 void put_autor(char *s) { strcpy(autor, s); }
 void mostrar_autor() { cout << autor << "\n"; }
};
class clase_D : public clase_B {
 char titulo[80];
public:
 void put_titulo(char *num) { strcpy(titulo, num); }
 void mostrar_titulo() {
   cout << "Titulo: ";
   cout << titulo << "\n";
 }
};
int main(){
  clase_B *p;
  clase_B objB;
  clase_D *dp; 
  clase_D objD;
  p = &objB;
  p->put_autor("Tom Clancy");
  p = &objD;
  p->put_autor("William Shakespeare");
  objB.mostrar_autor();
  objD.mostrar_autor();
  cout << "\n";
  *dp = objD;
  dp->put_titulo("La Tempestad");
  p->mostrar_autor();
  dp->mostrar_titulo();
  p->mostrar_titulo();
  return 0;
}


Herencia múltiple
Diga si las sentencias de main son legales o no y por que.

a.
#include <iostream>
using namespace std;
class base1 {
protected:
 int x;
public:
 void showx() { cout << x << "\n"; }
};
class base2 {
protected:
 int y;
public:
 void showy() { cout << y << "\n"; }
};
class derivada : public base1, public base2 {
public:
 void set(int i, int j) { x= i; y = j; };
};
int main(){
  derivada obj;
  obj.set(10, 20);
  obj.showx();
  obj.showy();
  return 0;
}

Funciones virtuales

Explique como funcionan los siguientes programas.

a.
#include <iostream>
using namespace std;
class base {
public:
  virtual void quien() {cout << "Base" << endl;}
};
class primera_d : public base {
public:
  void quien() {cout << "Primera derivacion" << endl;}
};
class segunda_d : public base {
public:
  void quien() {cout << "Segunda derivacion" << endl;}
};
int main(){
  base obj_base;
  base *p;
  primera_d obj_primera;
  segunda_d obj_segundo;
  p = &obj_base;
  p->quien();
  p = &obj_primera;
  p->quien();
  p = &obj_segunda;
  p->quien();
  return 0;
}

b.
#include <iostream>
using namespace std;
class base {
public:
  virtual void quien() {
    cout << "Base\n";
  }
};
class primera_d : public base {
public:
  void quien() {
   cout << "Primera derivacion\n";
  }
};
class segunda_d : public base {
public:
};
int main(){
  base obj_base;
  base *p;
  primera_d obj_primera;
  segunda_d obj_segunda;
  p = &obj_base;
  p->quien();
  p = &obj_primera;
  p->quien();
  p = &obj_segunda;
  p->quien();
  return 0;
}

c.
#include <iostream>
using namespace std;
class base {
public:
  virtual void quien() {
    cout << "Base\n";
  }
};
class primera_d : public base {
public:
  void quien() {
    cout << "Primera derivacion\n";
  }
};
class segunda_d : public primera_d {
};
int main(){
  base obj_base;
  base *p;
  primera_d obj_primera;
  segunda_d obj_segunda;
  p = &obj_base;
  p->quien();
  p = &obj_primera;
  p->quien();
  p = &obj_segunda;
  p->quien();
  return 0;
}

Cuál es el error en el siguiente programa? explique

#include <iostream>
using namespace std;
class figura {
protected:
 double x, y;
public:
  void set_dim(double i, double j=0) {
   x = i;
   y = j;
  }
  virtual void mostrar_area() = 0;
};
class triangulo : public figura {
public:
  void mostrar_area() {
    cout << "Triangulo con alto "; 
    cout << x << "  y base " << y;
    cout << " tiene un area de ";
    cout << x * 0.5 * y << ".\n";
  }
};
class rectangulo : public figura {
public:
  void mostrar_area() {
   cout << "Rectangulo con dimensiones "; 
   cout << x << " x " << y;
   cout << " tiene un area de ";
   cout << x * y << ".\n";
  };
};
class circulo : public figura {
};
int main(){
  figura *p;
  triangulo t;
  rectangulo r;
  circulo c;
  p = &t;
  p->set_dim(10.0, 5.0);
  p->mostrar_area();
  p = &r;
  p->set_dim(10.0, 5.0);
  p->mostrar_area();
return 0;
}
