lenguaje de programacion c++, Resúmenes de Programación C

¡Descarga lenguaje de programacion c++ y más Resúmenes en PDF de Programación C solo en Docsity!

LENGUAJE DE

PROGRAMACIÓN

C++

Introducción:

C++ es un lenguaje de programación orientado a objetos que toma la base del lenguaje C y le agrega la capacidad de abstraer tipos como en Smalltalk. C++ es un lenguaje de programación diseñado a mediados de los años 80 por Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que permitieran la manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido. Posteriormente se añadieron facilidades de programación genérica, que se sumó a los otros dos paradigmas que ya estaban admitidos (programación estructurada y la programación orientada a objetos). Por esto se suele decir que el C++ es un lenguaje de programación multiparadigma.

Sintaxis

/* Esta cabecera permite usar los objetos que encapsulan los descriptores stdout y stdin: cout(<<) y cin(>>)*/ #include using namespace std; int main() { cout << "Hola mundo" << endl; return 0 ; } Al usar la directiva #include se le dice al compilador que busque e interprete todos los elementos definidos en el archivo que acompaña la directiva (en este caso, iostream ). Para evitar sobrescribir los elementos ya definidos al ponerles igual nombre, se crearon los espacios de nombres o namespace del singular en inglés. En este caso hay un espacio de nombres llamado std , que es donde se incluyen las definiciones de todas las funciones y clases que conforman la biblioteca estándar de C++. Al incluir la sentencia using namespace std le estamos diciendo al compilador que usaremos el espacio de nombres std por lo que no tendremos que incluirlo cuando usemos elementos de este espacio de nombres, como pueden ser los objetos cout y cin , que representan el flujo de salida estándar (típicamente la pantalla o una ventana de texto) y el flujo de entrada estándar (típicamente el teclado). La definición de funciones es igual que en C, salvo por la característica de que si main no va a recoger argumentos, no tenemos por qué ponérselos, a diferencia de C, donde había que ponerlos explícitamente, aunque no se fueran a usar. Queda solo comentar que el símbolo << se conoce como operador de inserción, y grosso modo está enviando a cout lo que queremos mostrar por

Clases

Para declarar una clase, todo lo que se necesita es escribir una definición de estructura y sustituir la palabra reservada struct por class. Por ejemplo, una clase empleado con campos como el nombre, el departamento, la posición, el una función que nos imprima la información de este quedaría así: class Empleado { char* m_nombre; char* m_departamento; char* m_posicion; long m_salario; void Imprimir( Empleado infoEmpleado); } Cuando usted declara una clase en C++, no se reserva memoria para la clase hasta que usted crea un objeto de la clase. Crear un objeto de una clase se llama instanciar un objeto. Un objeto creado de una clase de denomina instancia de una clase. Por ejemplo, yo puedo tener una instancia de empleado con el valor en m_nombre=Jose, m_departamento=Sistemas, m_posicion=programador y m_salario=3000000 por ejemplo. Especificadores de acceso C++ utiliza especificadores de acceso para permitir controlar a una clase el acceso a las variables de datos de esa clase. Los especificadores de acceso permiten acceder a algunos miembros de la clase y restringir el acceso a otros. Hay tres especificadores de acceso en C++: public, private y protected. Cuando usted declara público ( public ) un miembro de una clase, usted permite el acceso a tal miembro desde dentro y fuera de la clase. Los miembros de datos que son declarados protegidos ( protected ) son únicamente accesibles por funciones miembro de la clase, pero no se pueden acceder a ellos desde otras clases. Cuando un miembro de una clase es declarado privado ( private ) es ináccesible no sólo desde otras clases y otras partes del programa, sino también desde sus clases derivadas. Las clases derivadas se explicara posteriormente. Miremos el siguiente programa de ejemplo. Se compone de tres partes: la primera una declaración de una clase llamada Empleado: class Empleado { private: char* m_nombre; char* m_departamento; char* m_posicion; long m_salario; public: void ImprimirInfo(); void SetNombre( char* nombre ) { m_nombre = nombre }

void SetDepartamento( char * departamento) { m_departamento = departamento } void SetPosicion ( char* posicion ) { m_posicion = posicion } void SetSalario ( long salario ) { m_salario = salario } const char* GetNombre( ){ return m_nombre } const char* GetDepartamento( ){ return m_departamento } const char* GetPosicion( ){ return m_posicion } const char* GetSalario( ){ return m_salario } }; Las funciones SetNombre, SetDepartamento, setPosicion, setSalario, GetNombre, GetDepartamento, GetPosicion y GetSalario se denominan funciones intercaladas, que son funciones que se declaran en una sola línea. Las variables de miembro son declaradas privadas para que funciones de miembro de otras funciones no tengan acceso a ellas sino a travez de la correspondiente funcion Get o Set. Las funciones de miembro si son declaradas públicas de tal modo que se pueda acceder a ellas desde otras funciones. La definición de la función PrintInfo puede quedar así: void Empleado::ImprimirInfo( ) { cout << "Nombre: " << m_nombre << '\n'; cout << "Departamento: " << m_departamento << '\n'; cout << "Puesto: " << m_posicion << '\n'; cout << "Salario: " << m_salario << '\n'; } Los dos dos puntos ( :: ) se denomina operador de resolución de ambito. Nos indica que la función que estamos definiendo que en este caso es ImprimirInfo, pertenece a la clase Empleado. La tercera parte es la función main. Veamos como podría ser: void main() { //creacion de un objeto de la clase Empleado Empleado empleado12; //asignacion de valores a las variables miembro empleado12.SetNombre("Jose"); empleado12.SetDepartamento("Sistemas"); empleado12.SetPosicion("Programador"); empleado12.SetSalario(3000000); //impresion de los datos empleado12.ImprimirInfo(); } Entonces, primero en : Empleado empleado12;

1. // Constructor declarado en la definición de la clase como función prototipo
2. Persona( const std::string& nombre, int edad, float peso, float estatura);
4. // Implementación fuera de la definición de la clase
5. Persona::Persona( const string& nombre, int edad, float peso, float estatura){
6. this -> nombre = nombre;
7. this -> edad = edad;
8. this -> peso = peso;
9. this -> estatura = estatura;
10. } La sintaxis para construir un objeto es la siguiente:
11. // Para un manejo automático de la memoria
12. NombreClase nombre_objeto; // constructor por defecto, la llamada va sin paréntesis
13. NombreClase nombre_objeto(arg1, arg2,..., argn); // constructor con parámetros
15. // Usando un apuntador y reservando memoria explícitamente
16. NombreClase* nombre_objeto = new NombreClase();
17. NombreClase* nombre_objeto = new NombreClase(arg1, arg2,..., argn); Error común : para usar el constructor por defecto con manejo automático de la memoria hay que evitar poner los paréntesis ya que de no ser así el compilador creerá que intentamos declarar el prototipo de una función.
18. // Error común, aquí el compilador cree que declaramos una función nueva llamada nombre_objeto, sin parámetros y que devuelve un objeto de NombreClase.
19. NombreClase nombre_objeto(); Hay dos maneras de usar el constructor: una que permite crear un objeto con manejo automático de la memoria que ocupa, y otra que nos permite utilizar un apuntador para manejar la memoria manualmente:  Objetos temporales : la primera manera nos otorga un objeto que podremos usar de manera muy similar a cualquier tipo de dato primitivo del lenguaje, por ejemplo un entero int. El objeto creado de esta manera permanecerá en memoria según el ámbito en que haya sido declarado , es decir, que una vez que el programa deje su ámbito, automáticamente se destruye el objeto y se libera la memoria que ocupaba.  Ventaja : nos podemos despreocupar por el manejo de la memoria.  Desventaja : hay que olvidarse de poder hacer polimorfismo con herencia (en notas posteriores discutiremos a fondo este punto).

 Apuntadores a objeto : la segunda manera proporciona la memoria necesaria para el objeto y nos otorga la dirección en un apuntador. Con esta alternativa debemos pedir la memoria explícitamente con la palabra reservada new y seremos responsables de liberarla cuando sea necesario, en otras palabras, nos toca destruir el objeto manualmente.  Ventaja : tenemos la posibilidad de usar técnicas avanzadas de programación (por ejemplo, polimorfismo).  Desventaja : debemos lidiar con la complejidad que implica el uso de apuntadores. Ahora veamos cómo instanciar una persona:

1. #include "Persona.h" //debemos incluir el archivo donde hicimos la declaración de la clase
2. int main(){
3. Persona persona("Verónica", 22 , 60 , 1.65); //objeto temporal
4. Persona* persona2; //apuntador a Persona
5. persona2 = new Persona("Verónica", 22 , 60 ,1.65);//asignación de la memoria para el objeto
6. delete persona2; //liberación de la memoria apuntada por persona
7. return 0 ;
8. } Como podemos observar se han creado dos objetos diferentes, de las dos manera explicadas anteriormente:  persona : es un objeto creado en el ámbito de la función main() , existirá mientras la ejecución del programa no deje el bloque de dicha función; al salir de ella la memoria es liberada automáticamente. Para acceder a los miembros del objeto (métodos y atributos) se utlizará el operador punto “.” :
9. persona.saluda();  persona2 : es un apuntador a objeto al cual se le ha asignado la dirección de memoria para manipular un objeto de la clase Persona. La liberación de la memoria depende de nosotros; así como la hemos pedido con new , debemos liberarla usando delete , si no lo hacemos es posible que esa memoria quede ocupada sin poder ser reasignada, al menos hasta que el programa deje de ejecutarse. La manera de acceder a los miembros del objeto es mediante el operador flecha “->” :
10. persona2->saluda();

Una operación (como el cálculo del perímetro o el área) que puede realizarse en un objeto Quadrilateral también puede realizarse en un objeto Rectangle. El polimorfismo se implementa por medio de funciones virtual. Cuando se hace una petición por medio de un apuntador de clase base (o referencia) , para utilizar una función virtual , C++ elige la función sobrepuesta correcta en la clase derivada adecuada que está asociada con ese objeto. Hay muchas veces en que una función miembro no virtual está definida en la clase base y sobrepuesta en una clase derivada. Si a una función de estas se le llama mediante un apuntador de clase base al objeto de la clase derivada, se utiliza la versión de la clase base. Si la función miembro se llama mediante un apuntador de la clase derivada, se utiliza la versión de dicha clase derivada. Este comportamiento no es polimórfico. Mediante el uso de funciones virtual y el polimorfismo, una llamada de función miembro puede causar que sucedan diferentes acciones, dependiendo del tipo de objeto que recibe la llamada. Esto le da una capacidad expresiva tremenda al programador. El polimorfismo promueve la extensibilidad: el software que está escrito para llamar al comportamiento polimórfico se escribe en forma independiente de los tipos de objetos a los cuales se envían los mensajes. Por lo tanto los nuevos tipos de objetos que pueden responder a los mensajes existentes se pueden agregar a un sistema, sin modificar el sistema base. #include <iostream.h> #include <math.h> #include <conio.h> // clase Shape class Shape { public: virtual double area() const { return 0.0; } virtual double volume() const { return 0.0; } // funcion virtual pura sobrepuesta en las clases derivadas virtual void print() const= 0 ; }; //////////////////////////////// // clase TwoDimensionalShape /// ////////////////////////////////

class TwoDimensionalShape : public Shape { public: virtual void print () const= 0 ; }; // clase triangulo class triangulo : public TwoDimensionalShape { double lado1, lado2, lado3; public: triangulo (double=0.0, double=0.0, double=0.0); void fijar_triangulo(double, double, double); virtual double area() const; virtual void print() const; }; triangulo :: triangulo (double l1, double l2, double l3){ fijar_triangulo(l1,l2,l3); } void triangulo :: fijar_triangulo (double l1, double l2, double l3){ lado1= l1 > 0? l1 : 0 ; lado2= l2 > 0? l2 : 0 ; lado3= l3 > 0? l3 : 0 ; } double triangulo :: area () const { double s; s=(lado1+lado2+lado3)/ 2 ; return sqrt(s(s-lado1)(s-lado2)*(s-lado3)); } void triangulo :: print () const { cout << endl << "Triangulo" << endl << "Lado 1= " << lado1 << endl << "Lado 2= " << lado2 << endl << "Lado 3= " << lado3; } // clase cuadrado class cuadrado : public TwoDimensionalShape { double lado; public: cuadrado (double=0.0); void fijar_cuadrado(double); virtual double area() const; virtual void print() const; };

double cubo :: volume () const { return ladoladolado; } void cubo :: print() const{ cout << endl << "Cubo" << endl <<"Lado= " << lado; }; // clase paralelepipedo class paralelepipedo : public ThreeDimensionalShape { double largo, ancho, altura; public: paralelepipedo(double=0.0, double=0.0, double=0.0); void fijar_paralelepipedo(double, double, double); virtual double area() const; virtual double volume() const; virtual void print() const; }; paralelepipedo :: paralelepipedo (double l, double a, double h){ fijar_paralelepipedo(l,a,h); } void paralelepipedo :: fijar_paralelepipedo (double l, double a, double h){ largo= l> 0? l : 0 ; ancho= a> 0? a : 0 ; altura= h> 0? h : 0 ; } double paralelepipedo :: area () const { return 2 largoancho + 4 anchoaltura; } double paralelepipedo :: volume () const { return largoanchoaltura; } void paralelepipedo :: print() const{ cout << endl <<"Paralelep¡pedo" << endl <<"Largo= " << largo << endl <<"Ancho= " << ancho << endl <<"Altura= " << altura; } // llama a funcion virtual a partir del apuntador de clase base

// utilizando enlace dinamico void virtualViaPointer (const Shape* baseClassPtr){ baseClassPtr->print(); cout << endl <<"Area= " << baseClassPtr->area() << endl <<"Volumen= " << baseClassPtr->volume() << endl; } // llama a funcion virtual a partir de referencia a clase base // utilizando enlace dinamico void virtualViaReference (const Shape& baseClassRef){ baseClassRef.print(); cout << endl <<"Area= " << baseClassRef.area() << endl <<"Volumen= " << baseClassRef.volume() << endl; } // funcion principal void main(){ clrscr(); triangulo t(5.2,6.5,7.1); virtualViaPointer (& t); virtualViaReference (t); cuadrado c(8.7); virtualViaPointer (&c); virtualViaReference (c); getch(); clrscr(); cubo cub(8.3); virtualViaPointer (&cub); virtualViaReference (cub); paralelepipedo p(4.5,6.7,9.2); virtualViaPointer (&p); virtualViaReference (p); getch(); }

Herencia:

C++ soporta herencia permitiendo a una clase incorporar otra clase dentro de su declaración. Antes de discutir los detalles y la teoría, se procede a comenzar por un ejemplo de herencia. La siguiente clase, llamada 'VehiculoRodante', define muy ampliamente a vehículos que viajan por la carretera. Este almacena el número de ruedas que un vehículo tiene y el número de pasajeros que puede llevar.

return this ->mRuedas; } _/*

• Función 'set_pasajeros'
• Recibe: num como int
• Devuelve: void
• Asigna al dato miembro 'mPasajeros' el valor 'num' /_ void set_pasajeros(int num) { this ->mPasajeros = num; } _/
• Función 'get_pasajeros'
• Recibe: void
• Devuelve: int
• Devuelve el valor que hay dentro del dato miembro 'mPasajeros' /_ int get_pasajeros(void) { return this ->mPasajeros; } _// PETICIONES/TRATAMIENTOS / Aquí van las funciones del tipo "Is", que generalmente devuelven true/false /_ private : _/ Generalmente en 'private' se sitúan los datos miembros */_ int mRuedas; int mPasajeros; };

Bibliografías:

https://blanchardspace.wordpress.com/2013/05/06/introduccion-a-c-que-es/ http://elvex.ugr.es/decsai/builder/index.html

Conclusión:

El lenguaje C++ presenta grandes herramientas de desarrollo para los programadores como las funciones, bibliotecas, clases y los objetos. De

manera que el programador se ocupa de utilizar dichas herramientas para resolver un problema específico. El lenguaje C++ posee una serie de características que lo hacen distinto del lenguaje C. Aunque es posible verlo como una simple extensión del lenguaje C, en realidad implica un cambio en la forma de pensar por parte del programador.