Storyboard

Java y C++ son muy similares por lo que es relativamente facil transforar un tipo de código en el otro.

>Modelo

ID:(1038, 0)

Descripción

Una clase en Java tiene la forma

```
class demojava {

// fields
private int x;

// constructor
public demojava(... argumentos ...){
... code ...
}

// method
public formato demometodo(... argumentos ...){
... 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 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 ...
}
};
```

Algunas diferencias claves son:
- se definen las variables globales (bajo privado)
- se definen los formatos de los métodos
- la clase se incluye en la definición
- el constructor se define con el nombre de la clase escrito dos veces y separado por "::"
- los métodos tienen su nombre propio y se les antepone el nombre de la clase separado por "::"

ID:(8543, 0)

Descripción

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)

Descripción

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)

Descripción

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)

Descripción

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)

Descripción

Una clase en Java tiene la forma

```
myclass object = new myclass();

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:

```
myclass object;

myclass 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)