Clases, Objetos y Métodos
Pablo San Segundo (C-206)
[email protected]
Índice











Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Inicialización de objetos miembro
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Introducción al concepto de clase (1/2)

Tipo de usuario para números complejos en C
//C style complex number type
struct complex_t {
double i;
double j;
};
double modulo(complex_t c){
return(sqrt(c.i*c.i + c.j*c.j));
};
//////////////////////////
void main(){
struct complex_t micomplejo={5.0, 5.0};
printf("modulo: %f\n", modulo(micomplejo));
}

En C++ se encapsulan los datos con las funciones que
operan sobre dichos datos en una clase

Cada instanciación de la clase se denomina objeto
Introducción al concepto de clase (2/2)
Tipo (de clase)
definido por el
usuario
#include “complex.h”
#include <iostream>
using namespace std;
void main(){
Complex micomplejo(5.0, 5.0);
cout<<"el modulo es:"<<micomplejo.modulo()<<endl;
}
Índice











Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Inicialización de objetos miembro
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Elementos de una clase

Identificador: el nombre de la
clase



Un conjunto de datos miembro
Un conjunto de funciones
miembro


Operan sobre los datos de la clase
Un conjunto de permisos



Semejante al nombre del tipo de
struct en C
Niveles de acceso a los datos y
funciones miembro de la clase
Restringe el acceso al
usuario/cliente de la clase
Declaración y definición
datos restringidos
Índice











Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Inicialización de objetos miembro
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Implementación en C++ de una clase (1/4)

Declaración: Se define el esqueleto de la clase




Prototipos de funciones miembro
Datos miembro
Lugar: <fichero de cabecera >(.h)
Definición: Contiene el código que compone las funciones
miembro

Lugar (por defecto): <fichero fuente> (.cpp)
DECLARACION
(complex.h)
class Complex{
public:
double i;
double j;
double modulo();
};
acceso a elementos
diferentes ‘dentro’ y
‘fuera’ de la clase
DEFINICIÓN (complex.cpp)
#include <math.h>
#include “complex.h”
double Complex::modulo(){
return sqrt(i*i+j*j);
}
USUARIO/CLIENTE DE LA CLASE (.cpp)
#include “complex.h”
void main(){
Complex micomplejo;
//objeto nuevo
micomplejo.i=5.0;
micomplejo.j=7.0;
cout<<micomplejo.modulo()<<endl;
}
Declaración de clase (2/4)
class <NOMBRE>
{
[<permiso de acceso A:>]
<Lista de datos/funciones miembro>
[<permiso de acceso B:>]
<Lista de datos/funciones miembro>
//…
} [Lista de objetos];
DECLARACION (.h)
class Complex{
private:
double i;
double j;
public:
void set(double i, double j);
double modulo();
}mic1, mic2;
DECLARACION (.h)
class Complex{
public:
double i;
double j;
double modulo();
}mic1, mic2;
Definición de función miembro (3/4)

Función miembro en fichero fuente
<tipo retorno> <ID_CLASE>::<ID_METODO>(<argumentos>)
{
[código del método]
}
DEFINICIÓN (.cpp)
#include “complex.h”
double Complex::modulo(){
return sqrt(i*i+j*j);
}
DEFINICIÓN (.cpp)
#include “complex.h”
void Complex::set(double i1, double j1){
i=i1;
j=j1;
}
Resumen (4/4)

Caso general



Declaración de clase en un archivo cabecera (.h)
Definición de métodos en un archivo fuente (.cpp)
Casos particulares


La declaración y definición de una clase pueden ir en un mismo
archivo fuente, pero entonces complica su reutilización
Se puede definir una función miembro como inline en el
fichero cabecera
DEFINICIÓN (complex.cpp)
DECLARACION
(complex.h)
class Complex{
public:
double i;
double j;
double modulo();
};
#include “complex.h”
double Complex::modulo(){
return sqrt(i*i+j*j);
}
DEFINICIÓN INLINE (complex.h)
class Complex{
public:
double modulo(){
return sqrt(i*i+j*j);
}
};
CLIENTE (main.cpp)
#include “complex.h”
void main(){
Complex micomplejo;
micomplejo.i = 8.0;
//…
}
Índice











Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Inicialización de objetos miembro
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Acceso a miembros

Variable objeto


Accede a sus miembros mediante “.”
Puntero a objeto

Accede a sus miembros mediante “->”
CLIENTE (main.cpp)
#include “complex.h”
void main(){
Complex micomplejo;
double m = micomplejo.modulo()
Complex* pc = & micomplejo;
m = pcmodulo();
}
CUESTIÓN
¿Acceso a los miembros mediante una
referencia al objeto?
Permisos y encapsulamiento (1/3)

private: miembros solo accesibles desde la propia clase (def. funciones
miembro)


Es el permiso por defecto
Excepción: declaración de amistad

public: miembros accesibles desde la propia clase y el exterior (cliente)

POO: niveles de acceso permiten “encapsular” el código


Los objetos se comportan autónomamente
Se pueden definir funcionalidades internas “invisibles” a otros objetos
CUESTIÓN
Indique semejanzas y diferencias del
concepto de permisos con un struct de C
EJERCICIO
Implemente los métodos de la clase ListaNum
de manera coherente
Fichero: “listanum.h”
#define MAX_ELEM 100
class ListaNum{
private:
int nElem;
int lista[MAX_ELEM];
public:
void add_elem (int dato);
int get_elem (int pos);
int get_size();
void print();
};
Permisos y encapsulamiento (2/3)
int ListaNum::get_size(){
return nElem;
}
int ListaNum::get_elem(int pos){
if(pos < nElem)
return lista[pos];
else return -1;
}
void ListaNum::add_elem (int dato){
if(nElem < MAX_ELEM)
lista[nElem ++]=dato;
}
void ListaNum::print(){
for(int i=0; i<nElem; i++)
cout<<lista[i]<<" ";
}
//constructor!
ListaNum::ListaNum(){
nElem=0;
}
Permisos y encapsulamiento (3/3)

La unidad de protección es la clase, no el objeto

Cualquier función miembro puede acceder a los datos de
cualquier objeto de su clase
DECLARACION (complex.h)
class Complex{
private:
double i;
double j;
public:
void foo(Complex& outer);
};
DEFINICIÓN (complex.cpp)
#include “complex.h”
void Complex::foo(Complex& outer)
{
cout<<“mi parte real: “<<i<<endl;
cout<<“parte real de outer: “<<outer.i<<endl;
}
Índice











Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Inicialización de objetos miembro
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Nociones generales de constructor
class Complex{
public:
Complex (double i, double j);
private:
double i;
double j;
};





Función miembro especial que garantiza que los objetos se
crean en un estado previsto por el diseñador de la clase
(inicializa los objetos en el momento de su creación)
Su nombre es el nombre de la clase
No retorna ningún valor: su prototipo no tiene tipo de
retorno
Es llamado en el momento de la creación del objeto
Existe un constructor por defecto


Llamado si el diseñador de la clase no ha definido constructor
Debe ser público en el caso general

Si el constructor es privado no se podrá crear ningún objeto de la
clase
Ejemplos
DECLARACION (.h)
class Complex{
private:
double i;
double j;
public:
Complex(double i, double j);
Complex() {i=0.0; j=0.0;}
//…
};
DECLARACION/DEF. EN LINEA (.h)
class Complex{
private:
double i;
double j;
public:
Complex(double i, double j){
Complex::i = i;
Complex::j = j;
}
};
Constructor sobrecargado
inline sin argumentos
EJERCICIO
Implemente un programa que defina
inicialmente un complejo (0, 0) y lo
modifique para encontrar el módulo
de (3,4).
Nota: modifique la clase Complex
adecuadamente
DEFINICIÓN (.cpp)
Complex::Complex(double i, double j){
Complex::i = i;
Complex::j = j;
}
Puntero this

this: puntero implícito asociado a cada objeto (instancia)
de la clase
APLICACIÓN AL CASO DEL CONSTRUCTOR (.cpp)
Complex::Complex(double i, double j){
this->i=i;
this->j=j;
}
Sintaxis de inicialización: ‘()’

Tipos base
int a(4);
float f(5.0);


//equivale int a=4
//equivale int f=5.0
Objeto
Complex micomplejo (4.0, 5.0);
//llama al constructor apropiado
Complex micomplejo;
//llama al const. sin arg. o pred.
Definición de un constructor (*.cpp)
Complex::Complex(): i(4.0) {double j=5.0;}
Complex::Complex(): i(4.0), j(5.0) {}

Definición de constructor inline (*.h)
Complex(): i(4.0), j(5,0) {}
Destructor de una clase
SINTAXIS (.cpp)
<ID CLASE>::~<ID CLASE>() {…}


Complemento del constructor
Es llamado justo antes de que el objeto deja de existir en
memoria


Para objetos globales (o estáticos) su vida coincide con la de
ejecución del programa




Ejemplo: objeto local al finalizar su bloque
El destructor será llamado al finalizar la ejecución del programa
El destructor es único para cada clase y no puede ser
sobrecargado
No tiene valor de retorno (al igual que el constructor)
No tiene argumentos
Ejemplo (I)
DECLARACION(complex.h)
class Complex{
private:
double i;
double j;
public:
Complex(double i, double j);
Complex();
~Complex();
//…
};
EJERCICIO
¿Valor de mod ?
¿Salida por pantalla?
DEFINICIÓN (complex.cpp)
Complex::~Complex(){
cout<<“Llamada al destructor”<<endl;
}
Complex::Complex(){
cout<<“Llamada al constructor”<<endl;
i=0.0; j=0.0;
}
TEST UNITARIO (test.cpp)
void main(){
Complex micomplejo;
Complex micomplejo_1 (5.0, 6.0);
double mod = micomplejo.modulo();
}
Ejemplo (II)

Para la clase Complex del ejercicio anterior:
Objeto estático
Objeto automático
CASO B
CASO A
int foo(){
Complex micomplejo;
return 0;
}
int foo(){
static Complex micomplejo;
return 0;
}
void main(){
for(int i=0; i<5; i++){
foo();
}
}
void main(){
for(int i=0; i<5; i++){
foo();
}
}
RECORDATORIO
Complex::~Complex(){
cout<<“Llamada al destructor”<<endl;
}
Complex::Complex(){
cout<<“Llamada al constructor sin argumentos”<<endl;
i=0.0; j=0.0;
}
Índice










Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Nociones generales de constructor copia


Permite inicializar un objeto con otro objeto de su misma
clase
Existe un constructor copia por defecto (al igual que
para el constructor normal)


Hace una copia simple del estado del objeto
Esta copia simple será suficiente mientras no existan datos
miembro que requieran asignación dinámica de memoria
Fichero fuente (foo.cpp)
Llama al constructor
copia por defecto al
no estar definido
class Foo {
int a;
int b;
Foo(const Foo&) {//…}
};
void main (){
Foo mifoo;
Foo mifoo_1(mifoo);
}
//ó Foo mifoo_1=mifoo;
Constructor copia: sintaxis
<ID_CLASE>::<ID_CLASE>(const <ID_CLASE>& obj) ;
Definición inline A (complex.h)
class Complex {
private:
double a, b;
public:
Complex(const Complex& micomp): a(micomp.a), b(micomp.b) {}
};
Ejemplo (I)
class Foo{
int vector[5];
public:
Foo(){cout<<"llamada al constructor sin parametros"<<endl;}
Foo(const Foo& cc){cout<<"llamada al constructor copia"<<endl;}
//…
};
USUARIO (.cpp)
void main(){
//…
Foo f1;
Foo f2 = f1;
//…
}
Ejemplo (II)
class Foo{
public:
int vector[5];
Foo(){cout<<"llamada al constructor sin parametros"<<endl;}
Foo(const Foo& cc){cout<<"llamada al constructor copia"<<endl;}
void print() {
for(int i=0; i<5; i++){cout<<vector[i]<<" ";}
}
//…
};
TEST UNITARIO (.cpp)
EJERCICIO I
¿Salida en pantalla?
EJERCICIO II*
Implemente la clase para poder
gestionar un vector de dimensión
variable.
¿Se observa alguna diferencia en
la construcción / destrucción?
void main(){
//…
Foo f1;
f1.vector[0]=0;
f1.vector[1]=1;
Foo f2 = f1;
f2.print();
//…
}
Solución parcial





Foo::Foo (int n);
Foo::Foo (const Foo& );
void Foo::print ();
void Foo::push_back (int dato);
~Foo::Foo();
TEST UNITARIO (.cpp)
void main(){
Foo f1(5);
f1.push_back(20);
f1.push_back(30);
Foo f2(f1);
f2.print();
}
Ejemplo (III): paso de un objeto por valor

En general se llamará al constructor copia cuando:


Se inicializa un objeto con otro del mismo tipo
Se pasa un objeto por valor a una función (objeto temporal)
DECLARACION (foo.h)
class Foo{
//…
Foo(const Foo& cc){cout<<"llamada al constructor copia"<<endl;}
};
int foofunc(Foo f){ return 0;}
Llamada al
constructor copia
//función independiente
TEST UNITARIO(.cpp)
void main(){
Foo f1;
foofunc(f1);
};
//paso objeto por valor
Índice











Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Inicialización de objetos miembro
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Consideraciones generales


CONSTRUCCIÓN: Se llama primero al constructor del
objeto miembro y luego al del objeto contenedor
DESTRUCCIÓN: llamada primero al destructor del objeto
contenedor y después al del objeto miembro (orden inverso)
class B{
public:
int dato;
B(){dato=0; cout<<"llamando al constructor de B sin parametros"<<endl;}
~B(){cout<<"llamando al destructor de B"<<endl;}
};
class A{
B b;
//dato miembro objeto de clase B
public:
A() {cout<<"llamando al constructor de A sin parametros"<<endl;}
~A(){cout<<"llamando al destructor de A"<<endl;}
};
void main(){
A a;
}
Ejemplo
DECLARACIONES (example.h)
class A{
A(){cout<<“Llamada al constructor de A”<<endl;}
};
class Foo{
A vector[10];
};
TEST UNITARIO(.cpp)
#include “example.h”
void main(){
Foo f1;
}
Múltiples objetos miembro
Declaración (.h)
class A{
int a1; int a2;
B b;
C c;
public:
A(int a1, int a2);
};
//objeto con constructor B(int, int)
//objeto con constructor C(int, int)
//constructor
Definición (I) (.cpp)
A::A(int x, int y):b(x,y), c(x,y) { a1=x; a2=y;}
Definición (II) (.cpp)
A::A(int x, int y):b(x,y), c(x,y), a1(x), a2(y) {}
EJERCICIO:¿Orden de llamada a los constructores?
Constructor copia en objetos miembro
class B{
public:
//…
B(){cout<<"llamando al constructor de B sin parametros"<<endl;}
B(const B&) {cout<<"llamando al constructor copia de B"<<endl;}
};
class A{
B b;
public:
A(){cout<<"llamando la constructor de A sin parametros"<<endl;}
A(const A& a): b(a.b){cout<<"llamando al constructor copia de A"<<endl;}
};
USUARIO (.cpp)
void main(){
A a;
A a1(a);
}
EJERCICIO:¿salida en pantalla?
REGLA: Definido el constructor copia del
contenedor, tiene TODA la responsabilidad de
las copias de sus objetos miembro
Índice











Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Inicialización de objetos miembro
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Creación/destrucción dinámica de objetos

Sintaxis new y delete similar a la vista para tipos base con las
siguientes diferencias:


Llamada al constructor en el momento de la creación (new)
Llamada al destructor antes de la liberación de memoria (delete)
Llama al constructor
predefinido de dos argumentos
OBJETO SIMPLE
void main(){
Complex * pcom = new Complex(5.0, 6.0);
delete pcom;
}
Llama al destructor antes de
liberar memoria
ARRAY DE OBJETOS
void main(){
int n=10;
Complex * pcom = new Complex[n];
delete [] pcom;
}
Llama al constructor sin
argumentos en los 10 objetos
Llama al destructor antes de liberar
memoria para cada objeto
Índice











Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Inicialización de objetos miembro
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Calificativo const para objetos


En C el calificativo de const para una variable de tipo base indica que
no puede ser un l-value. En C++ es necesario definir qué se entiende
por objetos constantes.
El comportamiento de un objeto constante queda caracterizado
por las funciones miembro declaradas como constantes:



Declaración: se añade const justo antes del “;”
Definición (inline o no): se añade const justo antes de “{“
Es posible polimorfismo en funciones miembro con respecto al
calificativo const.
“CONST” INLINE (.h)
class Complex{
//…
public:
//…
void print() const {
cout<<i<<“ “<<j<<endl;
}
};
“CONST” DEFINICION (.cpp)
void Complex::print() const {
cout<<i<<“ “<<j<<endl;
}
};
Calificativo const para atributos

El calificativo const para datos miembro se emplea para
aquéllos datos no modifican su valor a lo largo de la vida del
mismo


Solo se inicializan en la llamada al constructor
Hay que usar la notación “: “ en el constructor
Sintaxis “:”
obligatoria
DECLARACION
class Vector{
private:
const int SIZE;
//…
public:
Vector(int n): SIZE(n){}
void set(int n) {SIZE=n;}
};
INCORRECTO
MODIFICA UN DATO DE TIPO CONST
Calificativo const en el paso por referencia


Impide que la referencia pasada pueda usarse como un lvalue
Caso de ser una referencia a un objeto, se impide
cualquier llamada al interfaz público no constante de su
clase
EJEMPLO DE PASO POR REFERENCIA
void foo(const Complex & c){
c.print();
//print() debe ser tipo const
}
Índice











Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Inicialización de objetos miembro
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Calificativo static para objetos

Objetos de tipo static: generalización de las variables
estáticas de tipo base en C

El ciclo de vida de un objeto declarado static dura hasta el final
del programa
Declaración (.h)
class Foo{
int f;
public:
Foo() {cout<<“llamada al constructor sin parametros”<<endl;}
~Foo() {cout<<“llamada al destructor”<<endl;}
//…
};
Fuente(.cpp)
int func(){
static Foo;
//…
return 0;
}
void main(){
for(int i=0; i<10; i++) {func();}
}
Calificativo static para atributos de una clase



Un atributo static es común a todos los objetos de la clase (no
es accesible por this)
El nivel de acceso no se modifica
Es necesario inicializar un atributo estático en algún
momento y una única vez


Lo normal es en el fichero fuente donde se define la clase
Un atributo base static const se puede inicializar en la declaración
Declaración (Foo.h)
Definición (Foo.h/cpp)
class Foo{
static int numref;
public:
Foo() {numref++;}
~Foo() {numref--;}
//…
};
int Foo::numref = 0;
//…
Acceso desde fuera de la clase
<ID_CLASE>::<static_var>
//contador de objetos creados
Test Unitario (*.cpp)
void main(){
Foo f1, f2, f3;
cout<<“creados: “<<Foo::numref<<“objetos”;
}
Calificativo static para funciones miembro

Métodos comunes a todos los objetos de la clase


No accesibles por this
Solo pueden acceder a los atributos static de la
clase
class Foo{
static int numref;
public:
Foo() {numref++;}
~Foo() {numref--;}
static get_numref(){return numref;}
};
int Foo::numref = 0;
Ejemplo: patrón singleton
Constructor
privado
class Singleton{
private:
static Singleton* m_p;
//una única instancia
int a;
Singleton(int a):a(a){
cout<<"llamada al constuctor"<<endl;
}
public:
static Singleton* create_single_object(int a){
if(!m_p){m_p= new Singleton(a);}
Función estática miembro
return m_p;
Solo accede al dato
}
miembro static m_p
int get(){return a;}
};
¡Obligatorio!
Singleton* Singleton::m_p=NULL;
//inicializa m_p
Índice











Introducción al concepto de clase
Elementos de una clase
Implementación: declaración y definición
Permisos y encapsulamiento
Constructores y destructores
Constructor copia
Inicialización de objetos miembro
Creación dinámica de objetos
Calificativo const para objetos
Calificativo static para objetos
Calificativo friend para objetos
Declaración de amistad: friend


El calificativo friend inhibe los niveles de permisos de una
clase (desprotege su parte privada/protegida)
El calificativo se coloca en la declaración de la clase


Parte privada o pública, es irrelevante
Es aplicable a funciones independientes, métodos y clases


métodos / func. indep.: permiso de acceso individual
clases: permiso de acceso a todas sus funciones miembro
class A{
friend class B;
};
class A{
friend int B::foo(const A&);
};
REGLA GENERAL: Una función, método o clase con
calificativo friend en la declaración de otra clase tiene el
mismo nivel de permiso que las funciones miembro de
dicha clase.
INTUICIÓN: La parte privada de una clase es accesible
a los métodos de dicha clase y a sus amigos
Tipos de amistad




Función independiente amiga de una clase (I)
Función miembro amiga de una clase (II)
Función amiga de varias clases
Todas las funciones miembro de una clase B amigas de una
clase A (III)
Caso II (a.h)
Caso I (b.h)
#include
class A;
class A{
friend int B::foo(const A&);
};
//predeclaración de A
class B{
friend int foo(const A&);
};
“b.h”
Caso III (a.h)
La declaración de amistad de la
clase B no requiere conocimiento
de dicha clase en A
class A{
friend class B;
};
//dep. de B
Ejercicio
Implemente un ejemplo de uso de una función
independiente amiga de una clase y que permita acceder
a su parte privada para sacar en pantalla su estado
Compruebe que efectivamente la declaración de amistad
se salta el nivel de protección
Fichero: a.h
class A{
int dato;
friend void print(const A& a};
};
Fichero (.cpp) con visibilidad de a.h
#include <iostream>
#include “a.h”
void print (const A& a) { std::cout<<“dato: “<< a.dato; }
A tener en cuenta en la relación amistad


NO es una relación simétrica
NO es una relación transitiva


A amigo de B y B amigo de C no significa A amigo de C
Es necesario explicitar la relación para cada pareja
Ejercicio
Implemente una clase Punto para puntos de dos
dimensiones que contenga todas las funcionalidades vistas
hasta el momento:
A) Constructor sin argumentos (0.0, 0.0) y constructor
copia
B) Métodos getter y setter para la parte privada (las
coordenadas (x,y))
C) Método de visualización en pantalla
D) Función amiga independiente que devuelva la distancia
al origen
E) Test unitario: Validación de todas las funcionalidades
para un punto (3.0, 5.0)
Ejercicios de sintaxis
class A{
//… };
class A a1, a2;
class A{
private:
int dato
};
void foo(){
A a;
a.dato=0;
}
class C{
void C(){}
};
class C{
int x;
C()={x=5;}
};
//…
class C{
int x;
C(C c){x=c.x}
};
class C{
int x;
C(C& c){x=c.x}
};
class C{
static int x=10;
C(){}
};
class D{
static int x;
D(){}
};
D::x=10;
class A{
//…
};
void main(){
cout<<“hola mundo”;
}
class A{
//…
int a;
int b;
A(int d);
};
class Punto{
//…
int x;
int y;
void Punto(int x, int y);
};
class Punto{
//…
int x, y;
Punto(int x){Punto(x, x);}
Punto(int x, int y);
};
Ejercicios cortos
class Punto(){
int x, y;
Punto(int x, int y) {this->x=x; this->y=y;}
};
Punto vector[10];
class Punto{
int x, y;
Punto(int x=10, int y=20) {this->x=x; this->y=y;}
};
Punto vector[10];
Descargar

www.elai.upm.es