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)