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)