Storyboard

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

>Modell

ID:(1038, 0)

Beschreibung

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)

Beschreibung

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)

Beschreibung

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)

Beschreibung

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)

Beschreibung

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)

Beschreibung

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)