Benützer:
Comparación Java C++
Storyboard 
Java y C++ son muy similares por lo que es relativamente facil transforar un tipo de código en el otro.
ID:(1038, 0)
Estructura de Clases
Definition
Una clase en Java tiene la forma
```
class my_demo_class {
// fields
private int x;
// constructor
public demo(){
... code ...
}
// method
public int my_demo_method(int i){
... code ...
return value;
}
```
en que se supuso que se desea que la variable de la clase x fuera privada (opcional).
En el caso de C++ la clase se escribe como
```
class my_demo_class {
// fields
int x;
public
// constructor
demo() : x(0)
// initializes
{
... code ...
}
// method
int my_demo_method(int i){
... code ...
return value;
}
};
```
Las principales diferencias son
- sepearción en variables por tipo (privadas, publicas)
- constructor con encabezado distinto
- método muy similar pero no incluye el public
- final de la clase cerrado con ; en C++
ID:(8543, 0)
Estructura de Archivo Header
Bild
Si el archivo de la clase tiene la forma
```
class democpp {
private
// fields
... variables ...
public
... formatos metodos ...
// constructor
democpp(... argumentos ...)
democpp::democpp(... argumentos ...)
{
... code ...
}
// methods
int democpp::metodo(... argumento ...){
... code ...
}
int democpp::otrometodo(... argumento ...){
... code ...
}
};
```
el formato se resume en la definición de la clase bajo public. El archivo ".h" se puede definir directamente extrahiendo los formatos de los métodos y del constructor:
```
... formatos metodos ...
// constructor
democpp(... argumentos
```
ID:(8553, 0)
Ejemplo de Clase
Notiz
Como el archivo ".h" tiene la forma
```
... formatos metodos ...
// constructor
democpp(... argumentos
```
en el ejemplo de la clase abaco esto es
```
double sum(double a,double b);
double dif(double a,double b);
double prd(double a,double b);
double div(double a,double b);
//constructor
abaco();
```
que se debe almacenar en el archivo de nombre abaco.h.
ID:(8554, 0)
Ejemplo de Clase
Zitat
Un ejemplo simplificado puede ser una clase que suma, resta, multiplica y divide números.
Primero se define la clase en si, esto es los campos privados y los formatos que son públicos:
```
class abaco {
private:
// fields
double a;
double b;
public:
double sum(double a,double b);
double dif(double a,double b);
double prd(double a,double b);
double div(double a,double b);
//constructor
abaco();
};
```
Luego se define el constructor, sin formato de retiro y opcionlmente, con argumento
```
abaco::abaco()
{
}
```
Finalmente se incluyeno los métodos:
```
// method
double abaco::sum(double a,double b)
{
return a + b;
}
double abaco::dif(double a,double b)
{
return a - b;
}
double abaco::prd(double a,double b)
{
return a * b;
}
double abaco::div(double a,double b)
{
if(b != 0){
return a / b;
} else {
return 0;
}
}
```
Todo se almacena en un archivo de nombre igual a la clase (abaco) y extensión cpp.
ID:(8552, 0)
Uso de Objetos
Übung
En el uso de objetos Java y C++ son idénticos.
Se pueden ejecutar los métodos mediante la concatenación con puntos. Si el objeto es p y el método la "sum" la suma de dos variables se tiene que
```
double result = p.sum(a,b);
```
donde a y b son valores.
ID:(8555, 0)
Creación de Objetos
Gleichung
Una clase en Java tiene la forma
```
my_demo_class object = new my_demo_class();
my_demo_class object = new my_demo_class(arguments);
```
donde my_demo_class es el nombre de la clase yla segunda definición corresponde al caso en que hay argumentos y arguments es la lista de estos.
En el caso de C++ los objetos se definen como:
```
my_demo_class object;
my_demo_class object(arguments);
```
Las principales diferencias son
- C++ realiza las definiciones como cualquier otro tipo de variable no usando el comando new y sin igualar un puntero a un constructor
ID:(8544, 0)