1. Libros
  2. De C a C++ - De la programación procedural al objeto

De C a C++ De la programación procedural al objeto

  • Acceso ilimitado 24/7
  • Todos los libros online de ENI
  • Novedades todos los meses
  • Acceso 100% online
  • Disponible
  • Envío gratis a partir de 25 € de compra
  • Versión online gratis
  • Acceso gratuito a todos nuestros libros online durante 1 hora por toda compra
  • Consulta inmediata
  • Versión HTML online
  • Acceso ilimitado 24/7

Presentación

Este libro se dirige a desarrolladores principiantes que desean dominar el diseño de algoritmos usando el lenguaje C y el lenguaje C++. La eficacia y la complementariedad así como la generalidad de estos lenguajes permitirán al lector adquirir una experiencia fundamental en la programación informática para a continuación evolucionar fácilmente con otros lenguajes de programación. El autor ha logrado no sólo exponer el funcionamiento de las herramientas fundamentales de ambos lenguajes sino también proporcionar los medios para ponerlos en práctica. De este modo, cada sección teórica va seguida de una sección de "puesta en práctica", compuesta de variados ejercicios.

El conjunto de fundamentos de programación y de diseño algorítmico se organiza a partir de la noción de  estructuras de datos, siguiendo un recorrido que va de las más simples a acabando con la más compleja: el objeto. Los cuatro primeros capítulos están dedicados al aprendizaje del lenguaje C y al uso de las primeras técnicas en algorítmica, de las variables simples, pasando por tablas y las tuplas hasta llegar a los punteros. A continuación, siempre en lenguaje C, se tratan estructuras de datos complejas: listas enlazadas dinámicas y estáticas, así como pilas, colas y árboles, básicamente  árboles binarios. Para ello, un capítulo explica las claves de la recursividad, elemento imprescindible para la implementación de árboles en C y C++. Estas estructuras de datos se presentan entre el lenguaje C y el lenguaje C++ para ilustrar el paso que pueden representar entre el mundo sin objetos del lenguaje C y el mundo de los objetos de C++.

La última parte presenta las características y el paradigma orientado a objetos del lenguaje C++. Se tratan todos los puntos importantes con pequeños programas de ejemplo. El objetivo es proporcionar al lector un sendero consecuente hacia el mundo orientado a objetos y a otros lenguajes orientados a objetos y darle las claves para pasar a Java o C#, por ejemplo.

Hay elementos disponibles para su descarga en www.ediciones-eni.com.


Los capítulos del libro:
Introducción - Variables simples - Los controles de flujo - Variables de conjunto (tuplas y tablas) - Variables puntero - Recursividad - Estructuras de datos y algoritmos - Variables objeto, descubrir C++ - Anexo

Índice

  • Introducción
    • 1. Objetivo: aprender a programar
    • 2. Contenido del curso
    • 3. ¿ A quién va dirigido ?
    • 4. ¿ Cómo aprender a programar ?
      • 4.1 Comprender no es saber
      • 4.2 Tres niveles de dificultad
        • 4.2.1 Dominar las herramientas
        • 4.2.2 Resolver un problema
        • 4.2.3 Diseñar un programa
      • 4.3 Un aprendizaje no lineal
    • 5. Organización del libro
      • 5.1 Capítulos
      • 5.2 Soluciones de los ejercicios
      • 5.3 Anexos
    • 6. Entornos de desarrollo
    • 7. Agradecimientos
    • 8. Conclusión: la programación como escritura
  • Variables simples
    • 1. Introducción a la programación en C
      • 1.1 ¿ Qué es programar ?
      • 1.2 El posicionamiento en relación con el ordenador
      • 1.3 Los elementos de la programación
        • 1.3.1 El compilador
        • 1.3.2 El IDE: entorno de desarrollo
        • 1.3.3 Instalación
      • 1.4 Los pilares de un programa
        • 1.4.1 Datos e instrucciones
        • 1.4.2 «Librerías» de funciones
      • 1.5 Primer programa
        • 1.5.1 La función main(): punto de entrada del programa
        • 1.5.2 Visualizar texto con la función printf()
      • 1.6 Puesta en práctica: descubriendo el compilador
    • 2. Variables simples
      • 2.1 ¿ Qué es una variable en informática ?
      • 2.2 Usar variables en un programa
        • 2.2.1 Tipos de variables primitivos en C
        • 2.2.2 Declaración de variables en un programa
        • 2.2.3 Restricciones en la elección de nombres
      • 2.3 Puesta en práctica: tener variables en un programa
      • 2.4 Operaciones básicas con variables
        • 2.4.1 Asignar un valor a una variable
        • 2.4.2 Valores de tipo carácter (código ASCII)
        • 2.4.3 printf() para mostrar valores
        • 2.4.4 Obtener y visualizar el tamaño en memoria de una variable
        • 2.4.5 Obtener y visualizar la dirección en memoria de una variable
        • 2.4.6 scanf() para obtener un valor entrado por el usuario
        • 2.4.7 Las trampas de scanf()
      • 2.5 Puesta en práctica: operando con variables
      • 2.6 Para comprender las variables
        • 2.6.1 Codificación y tamaño de la información
        • 2.6.2 Rangos de valores en decimal
        • 2.6.3 Truncamiento
        • 2.6.4 Codificación de números negativos
      • 2.7 Puesta en práctica: codificación de datos numéricos
      • 2.8 Experimento: variables simples, declaración, asignación, visualización y entrada de datos
    • 3. Operaciones
      • 3.1 Noción de expresión
      • 3.2 Operaciones aritméticas
        • 3.2.1 Operadores +, -, *, /, %
        • 3.2.2 Asignaciones combinadas
        • 3.2.3 Pre y posincrementos o decrementos
        • 3.2.4 Operaciones entre tipo distintos, operador de «cast»
        • 3.2.5 Prioridades entre operadores
      • 3.3 Puesta en práctica: operaciones aritméticas, cast
      • 3.4 Obtener valores aleatorios
        • 3.4.1 Principio de pseudoaleatoriedad
        • 3.4.2 La función rand()
        • 3.4.3 La función srand()
        • 3.4.4 Valores aleatorios en rangos definidos
      • 3.5 Puesta en práctica: operaciones y números aleatorios
      • 3.6 Operaciones bit a bit
        • 3.6.1 Y - operador &
        • 3.6.2 O exclusivo - operador ^
        • 3.6.3 O inclusivo - operador |
        • 3.6.4 COMPLEMENTO - operador ~
        • 3.6.5 Operadores de desplazamiento a izquierda y derecha - operadores >> y <<
        • 3.6.6 Prioridades de los operadores bit a bit
      • 3.7 Puesta en práctica: operaciones bit a bit
      • 3.8 Experimento: operaciones aritméticas, valores aleatorios
  • Controles de flujo
    • 1. Bloques de instrucciones y condiciones
      • 1.1 ¿ Qué es un bloque de instrucciones ?
        • 1.1.1 Definición
        • 1.1.2 Ejemplo
        • 1.1.3 Utilidad de un bloque de instrucciones
      • 1.2 Definir una condición
        • 1.2.1 ¿ Por qué una condición ?
        • 1.2.2 ¿ Cómo definir una condición ?
        • 1.2.3 Los operadores de comparación
        • 1.2.4 El operador unario de negación !
        • 1.2.5 Prioridades de los operadores de negación y de comparación
      • 1.3 Puesta en práctica: operadores de comparación y negación
    • 2. Saltos condicionales
      • 2.1 La instrucción if
      • 2.2 La pareja de instrucciones if-else
      • 2.3 La forma compacta de if-else, operador condicional ?
      • 2.4 Instrucciones if-else if-else en cascada
      • 2.5 Experimento: los saltos condicionales (los tres if)
      • 2.6 Puesta en práctica: saltos condicionales
    • 3. Caminos alternativos
      • 3.1 Selección de caminos alternativos: switch, case y break
      • 3.2 Ruptura de la secuenciación: goto con etiqueta
      • 3.3 Experimento: selección de caminos alternativos con switch
      • 3.4 Puesta en práctica: caminos alternativos con switch
    • 4. Evaluación de multicondiciones (Y/O)
      • 4.1 Conjunción Y, operador &&
        • 4.1.1 Y con dos expresiones miembro
        • 4.1.2 Y con más de dos expresiones miembro
      • 4.2 Disyunción O, operador ||
        • 4.2.1 O con dos expresiones miembro
        • 4.2.2 O con más de dos expresiones miembro
      • 4.3 Y prioritario sobre O
      • 4.4 Prioridad respecto al resto de los operadores
      • 4.5 Puesta en práctica: operadores lógicos Y, O
    • 5. Bucles
      • 5.1 Bucle MIENTRAS QUE: while
      • 5.2 Bucle HACER {...} MIENTRAS QUE: do-while
      • 5.3 Bucle PARA: for
      • 5.4 Bucles anidados
      • 5.5 Salida y salto forzados en un bucle
        • 5.5.1 Salir con la instrucción break
        • 5.5.2 Pasar a la siguiente iteración con la instrucción continue
        • 5.5.3 Salir de uno o varios bucles anidados con la instrucción goto
      • 5.6 Puesta en práctica: bucles while, do-while y for
    • 6. Uso típico de bucles
      • 6.1 Crear un menú de usuario
      • 6.2 Bucle de eventos en un videojuego
        • 6.2.1 Obtener las entradas de teclado (kbhit() y getch())
        • 6.2.2 Bucle de eventos simple
        • 6.2.3 Controlar el tiempo de ejecución
      • 6.3 Comenzar la creación de un juego en modo consola
      • 6.4 Puesta en práctica: menús y bucles de eventos
    • 7. Funciones
      • 7.1 ¿ Qué es una función ?
      • 7.2 Escribir una función
        • 7.2.1 ¿ Dónde se escriben las funciones ?
        • 7.2.2 Condiciones que se deben cumplir
        • 7.2.3 Ejemplo de función sin retorno ni parámetros
        • 7.2.4 Ejemplo de función con retorno, pero sin parámetros
        • 7.2.5 Ejemplo de función sin retorno con un parámetro
        • 7.2.6 Ejemplo de función con retorno y un parámetro
        • 7.2.7 Conclusión: cuatro casos de escritura de funciones
      • 7.3 Utilizar la función
        • 7.3.1 Llamada a la función
        • 7.3.2 Recuperación del valor de retorno
        • 7.3.3 Paso de valores a los parámetros
        • 7.3.4 Precisión sobre el paso por valor
        • 7.3.5 Visibilidad y declaración de funciones
      • 7.4 Ejemplo de funciones con una lista variable de parámetros
        • 7.4.1 Lista variable de parámetros del mismo tipo
        • 7.4.2 Lista variable de parámetros de tipo distinto
        • 7.4.3 Transformar printf()
      • 7.5 Puesta en práctica: funciones
        • 7.5.1 Identificar los componentes de una función
        • 7.5.2 Declaración de funciones
        • 7.5.3 Procedimientos sin parámetro
        • 7.5.4 Funciones sin parámetros
        • 7.5.5 Funciones con parámetros
    • 8. Estilo, comentarios e indentación
      • 8.1 ¿ Por qué tratar el estilo ?
      • 8.2 Tipografía y elección de nombres
      • 8.3 Indentación rigurosa y llaves
      • 8.4 Paréntesis para eliminar ambigüedades
      • 8.5 Comentarios pertinentes
      • 8.6 Puesta en práctica: estilo, indentación, comentarios
  • Variables de conjunto (tuplas y tablas)
    • 1. Tupla
      • 1.1 ¿ Qué es una tupla ?
      • 1.2 Poder usar una tupla en un programa
        • 1.2.1 Definir un tipo de tupla
        • 1.2.2 Declarar las variables de la tupla
      • 1.3 Utilizar una tupla
        • 1.3.1 Acceso a los elementos con el operador punto
        • 1.3.2 Prioridad del operador punto
        • 1.3.3 Una tupla como campo de otra tupla
        • 1.3.4 Inicializar una tupla en la declaración
        • 1.3.5 Copiar una tupla
      • 1.4 Puesta en práctica: definir, declarar, inicializar tuplas
    • 2. Tuplas y funciones
      • 2.1 Devolver una tupla
      • 2.2 Tuplas como parámetros de función
      • 2.3 Experimento: una entidad móvil por la pantalla
      • 2.4 Puesta en práctica: tuplas y funciones
    • 3. Typedef, enum y #define
      • 3.1 Utilizar un typedef
      • 3.2 Utilizar un enum
      • 3.3 Utilizar un #define
      • 3.4 Puesta en práctica: typedef, enum y #define
    • 4. Tablas estáticas
      • 4.1 ¿ Qué es una tabla ?
      • 4.2 Crear una tabla estática en un programa
        • 4.2.1 Definir y declarar una tabla
        • 4.2.2 Utilizar #define para los tamaños
      • 4.3 Utilizar una tabla
        • 4.3.1 Acceder a los elementos de la tabla con el operador corchete [ ]
        • 4.3.2 Prioridad del operador corchete
        • 4.3.3 Desbordamiento de tabla
        • 4.3.4 Inicializar una tabla en la declaración
        • 4.3.5 Recorrer una tabla con un bucle for
        • 4.3.6 Ordenar una tabla
      • 4.4 Tablas de varias dimensiones
        • 4.4.1 Declarar una tabla de varias dimensiones
        • 4.4.2 Inicializar en la declaración
        • 4.4.3 Recorrer una tabla con múltiples dimensiones
      • 4.5 Experimento: tablas estáticas
      • 4.6 Puesta en práctica: operaciones básicas con tablas estáticas (no dinámicas)
        • 4.6.1 Declaración de tablas, acceso a los elementos
        • 4.6.2 Inicialización de tablas en la declaración
        • 4.6.3 Tablas de varias dimensiones
        • 4.6.4 Bucles y tablas
    • 5. Ejemplos de uso de tablas
      • 5.1 Cadenas de caracteres
      • 5.2 Imagen de mapa de bits
      • 5.3 Almacenar datos localizados
      • 5.4 Experimento: utilización de cadenas de caracteres
      • 5.5 Puesta en práctica: tablas
        • 5.5.1 Cadenas de caracteres
        • 5.5.2 Imagen, terreno de juego
        • 5.5.3 Localización de datos con varias dimensiones
    • 6. Tablas y tuplas
      • 6.1 Tabla como campo de una tupla
      • 6.2 Tabla de tuplas
      • 6.3 Diferencias entre tablas y tuplas
      • 6.4 Puesta en práctica: tablas y tuplas
    • 7. Tablas y funciones
      • 7.1 Utilizar una tabla declarada en global
      • 7.2 Tabla como parámetro de función
        • 7.2.1 Precisión sobre el tipo tabla
        • 7.2.2 La variable puntero
        • 7.2.3 En parámetro, conversión de tabla a puntero
        • 7.2.4 Elección para escribir tablas como parámetros de función
        • 7.2.5 Modificación de datos mediante un paso de parámetros por referencia
      • 7.3 Algunas funciones de tratamiento de cadenas de caracteres
        • 7.3.1 Recuperar una cadena de caracteres entrada por el usuario
        • 7.3.2 Obtener el tamaño de una cadena
        • 7.3.3 Copiar una cadena
        • 7.3.4 Comparar dos cadenas
        • 7.3.5 Concatenar dos cadenas
      • 7.4 Experimento: tablas y funciones
      • 7.5 Puesta en práctica: tablas y funciones
        • 7.5.1 Llamadas a funciones, tablas por parámetro
        • 7.5.2 Operaciones con cadenas
    • 8. Gestión de variables
      • 8.1 Visibilidad de variables
        • 8.1.1 Profundidad de la declaración
        • 8.1.2 Ámbito de las variables
        • 8.1.3 Enmascaramiento de una variable
      • 8.2 Tiempo de vida de las variables
        • 8.2.1 Variables globales
        • 8.2.2 Variables locales (auto)
        • 8.2.3 Variables static
      • 8.3 Elección de metodologías
      • 8.4 Puesta en práctica: gestión de variables
    • 9. Estructuración de un programa, estudio de un autómata celular
      • 9.1 Aclarar y definir los objetivos
        • 9.1.1 Principio del autómata celular
        • 9.1.2 Funcionamiento deseado
      • 9.2 Encontrar una estructura de datos adecuada
      • 9.3 Identificar las funciones principales
      • 9.4 Elegir el nivel de las variables fundamentales
      • 9.5 Escribir las funciones
        • 9.5.1 Función de inicialización
        • 9.5.2 Función de visualización
        • 9.5.3 Función de cálculo
        • 9.5.4 Función para contar vecinos
        • 9.5.5 Función de copia
        • 9.5.6 Montaje en el main()
      • 9.6 Integrar una librería personal
      • 9.7 Repartir el código en varios archivos C
      • 9.8 Puesta en práctica: estructuración de un programa
        • 9.8.1 Simulación de un incendio forestal
        • 9.8.2 Tristus y alegrus
        • 9.8.3 Simulación de un ataque de microbios en la sangre
        • 9.8.4 Bancos de peces, movimientos de población
        • 9.8.5 Elección presidencial
        • 9.8.6 Oruga
        • 9.8.7 Sistema de vida artificial, colonias de hormigas
        • 9.8.8 Botones y páginas
        • 9.8.9 Paneles de madera y almacenes
        • 9.8.10 Nenuphs et clans
        • 9.8.11 Nieve 1
        • 9.8.12 Nieve 2
        • 9.8.13 Nieve 3
        • 9.8.14 Arkanoid sencillo
        • 9.8.15 Arkanoid gurú
        • 9.8.16 Space invaders sencillo
        • 9.8.17 Space invaders avanzado
        • 9.8.18 Space invaders gurú
        • 9.8.19 Pacman sencillo
        • 9.8.20 Pacman avanzado
        • 9.8.21 Pacman gurú
        • 9.8.22 Juego de los espejos
        • 9.8.23 Simulador de fútbol
  • Variables puntero
    • 1. Principios de un puntero
      • 1.1 ¿ Qué es un puntero ?
        • 1.1.1 Memoria RAM
        • 1.1.2 Una variable puntero
        • 1.1.3 Cuatro operadores
        • 1.1.4 Tres utilizaciones básicas de los punteros
      • 1.2 Declarar un puntero en un programa
      • 1.3 Funcionamiento de los cuatro operadores
        • 1.3.1 Operador de dirección: &
        • 1.3.2 Operador asterisco: *
        • 1.3.3 Operador flecha: ->
        • 1.3.4 Operador corchete: [ ]
        • 1.3.5 Prioridad de los cuatro operadores
      • 1.4 Asignación dinámica de memoria
        • 1.4.1 La función malloc()
        • 1.4.2 Liberar la memoria asignada: la función free()
        • 1.4.3 El puntero genérico void*
        • 1.4.4 El valor NULL
      • 1.5 Atención a la validez de una dirección de memoria
        • 1.5.1 Validez de una dirección de memoria
        • 1.5.2 ¿ Por qué hay que realizar casting con el retorno de las funciones de asignación ?
      • 1.6 Caso de las tablas de punteros
        • 1.6.1 Una estructura de datos muy útil
        • 1.6.2 Una tabla de cadenas de caracteres
        • 1.6.3 Utilizar los argumentos de línea de comandos
      • 1.7 Experimento: conocimientos básicos de punteros
      • 1.8 Puesta en práctica: conocimientos básicos de punteros
        • 1.8.1 Declarar punteros y operar con ellos
        • 1.8.2 Pruebas con tablas/punteros
        • 1.8.3 Conocimientos básicos de asignación dinámica
        • 1.8.4 Ojo con los errores
        • 1.8.5 Tablas de cadenas
    • 2. Asignación dinámica de tablas
      • 2.1 Asignar dinámicamente una tabla con un puntero
      • 2.2 Asignar una matriz con un puntero de punteros
      • 2.3 Diferencias entre tablas estáticas y tablas dinámicas
      • 2.4 Otras funciones de asignación de memoria dinámica
        • 2.4.1 Función calloc()
        • 2.4.2 Función realloc()
      • 2.5 Puesta en práctica: asignación dinámica de memoria
        • 2.5.1 Asignar dinámicamente tablas
        • 2.5.2 Asignar memoria dinámicamente a matrices
        • 2.5.3 Asignación dinámica de memoria con calloc() y realloc()
    • 3. Punteros como parámetros de función
      • 3.1 Paso por referencia
        • 3.1.1 Caso general de una variable cualquiera
        • 3.1.2 Ejemplo: una función que devuelve la hora
        • 3.1.3 Paso por referencia de una tupla
        • 3.1.4 Paso por referencia de una variable puntero
      • 3.2 Tablas dinámicas por parámetro
      • 3.3 Puesta en práctica: paso por referencia
        • 3.3.1 Paso por referencia, conocimientos básicos
        • 3.3.2 Paso por referencia, operadores bit a bit
        • 3.3.3 Paso de punteros por referencia
        • 3.3.4 Paso de tablas dinámicas
    • 4. Archivos (tipo FILE*)
      • 4.1 Nociones básicas
        • 4.1.1 El tipo FILE*
        • 4.1.2 Apertura y cierre de un archivo
        • 4.1.3 Especificar una ruta de acceso
      • 4.2 Archivos binarios
        • 4.2.1 Escritura y lectura en modo binario
        • 4.2.2 Detectar el final del archivo binario
        • 4.2.3 Desplazamientos en un archivo
      • 4.3 Escritura y lectura en modo texto
        • 4.3.1 Detectar el final de un archivo, EOF y feof()
        • 4.3.2 Lectura/escritura de caracteres
        • 4.3.3 Lectura/escritura de cadenas
        • 4.3.4 Lectura/escritura con formato
      • 4.4 Copia de seguridad de elementos dinámicos
        • 4.4.1 Guardar y cargar una tabla dinámica
        • 4.4.2 Obtener datos mediante punteros
      • 4.5 Puesta en práctica: archivos
  • Recursividad
    • 1. Funciones recursivas
      • 1.1 ¿ Qué es la recursividad ?
      • 1.2 Una función recursiva básica
      • 1.3 Pila de llamadas y desbordamiento
      • 1.4 Devolver un valor
      • 1.5 Representación y análisis de funcionamiento
        • 1.5.1 Análisis descendiente
        • 1.5.2 Análisis ascendiente
      • 1.6 Elegir entre iterativo o recursivo
    • 2. Ejemplos clásicos de funciones recursivas
      • 2.1 Cálculos
        • 2.1.1 Mostrar las cifras de un entero
        • 2.1.2 Producto factorial
        • 2.1.3 Sucesión de Fibonacci
        • 2.1.4 Cambio de base aritmética de un número
        • 2.1.5 Potencia
        • 2.1.6 MCD, algoritmo de Euclides
      • 2.2 Dibujos
        • 2.2.1 Dibujo de una regla graduada: «divide y vencerás»
        • 2.2.2 Dibujar circunferencias
        • 2.2.3 Dibujar cuadrados
        • 2.2.4 Dibujar un árbol
      • 2.3 Crear juegos
        • 2.3.1 Encontrar un camino en un laberinto
        • 2.3.2 Crear un laberinto
      • 2.4 Torres de Hanói
      • 2.5 Quicksort de una tabla de números
    • 3. Puesta en práctica: recursividad
  • Estructuras de datos y algoritmos
    • 1. Listas enlazadas dinámicas
      • 1.1 ¿ Qué es una lista enlazada ?
        • 1.1.1 Una cadena formada de enlaces
        • 1.1.2 Cuatro tipos de listas enlazadas
        • 1.1.3 Acciones aplicables a una lista enlazada
        • 1.1.4 Listas enlazadas vs. tablas
      • 1.2 Implementar una lista simple
        • 1.2.1 Estructura de datos de un elemento
        • 1.2.2 Comienzo y fin de la lista
        • 1.2.3 Inicializar un elemento
        • 1.2.4 Añadir un elemento al comienzo de una lista
        • 1.2.5 Insertar un elemento en una lista
        • 1.2.6 Recorrer la lista
        • 1.2.7 Eliminar un elemento al comienzo de la lista
        • 1.2.8 Eliminar un elemento según un criterio
        • 1.2.9 Destruir listas
        • 1.2.10 Guardar listas
      • 1.3 Implementar una lista simple circular
        • 1.3.1 Estructura de datos de una lista circular
        • 1.3.2 Lista vacía
        • 1.3.3 Comienzo y fin de la lista
        • 1.3.4 Inicializar un elemento
        • 1.3.5 Añadir un elemento
        • 1.3.6 Recorrer la lista
        • 1.3.7 Eliminar un elemento
        • 1.3.8 Destruir listas
      • 1.4 Implementar una lista doblemente enlazada
        • 1.4.1 Estructura de datos
        • 1.4.2 Lista vacía
        • 1.4.3 Comienzo y final de la lista
        • 1.4.4 Inicializar un elemento
        • 1.4.5 Añadir un elemento al comienzo
        • 1.4.6 Añadir un elemento al final
        • 1.4.7 Recorrer y mostrar la lista
        • 1.4.8 Eliminar un elemento
        • 1.4.9 Destruir la lista
        • 1.4.10 Copiar una lista
      • 1.5 Puesta en práctica: listas enlazadas
    • 2. Pilas
      • 2.1 Principio de las pilas
        • 2.1.1 Modelo de datos pila
        • 2.1.2 Implementación estática o dinámica
        • 2.1.3 Primitivas de gestión de pilas
        • 2.1.4 Aplicaciones importantes de las pilas
      • 2.2 Implementación de una pila dinámica
        • 2.2.1 Estructura de datos
        • 2.2.2 Pila vacía, pila llena
        • 2.2.3 Inicialización
        • 2.2.4 Apilar
        • 2.2.5 Obtener la cima
        • 2.2.6 Desapilar
        • 2.2.7 Vaciar, destruir
        • 2.2.8 Mostrar
        • 2.2.9 Prueba en el main()
      • 2.3 Implementación de una pila estática (en una tabla)
        • 2.3.1 Estructura de datos
        • 2.3.2 Inicialización
        • 2.3.3 Pila vacía, pila llena
        • 2.3.4 Apilar
        • 2.3.5 Obtener la cima
        • 2.3.6 Desapilar
        • 2.3.7 Vaciar, destruir
        • 2.3.8 Mostrar
        • 2.3.9 Prueba en el main()
      • 2.4 Puesta en práctica: pilas
    • 3. Colas
      • 3.1 Principios de las colas
        • 3.1.1 Modelo de datos cola
        • 3.1.2 Implementación estática o dinámica
        • 3.1.3 Primitivas de gestión de archivos
        • 3.1.4 Aplicaciones importantes de las colas
      • 3.2 Implementación de una cola dinámica
        • 3.2.1 Estructura de datos
        • 3.2.2 Cola vacía, cola llena
        • 3.2.3 Inicialización
        • 3.2.4 Encolar
        • 3.2.5 Obtener el primero, obtener el último
        • 3.2.6 Avanzar
        • 3.2.7 Vaciar, destruir
        • 3.2.8 Mostrar
        • 3.2.9 Prueba en el main()
      • 3.3 Implementación de una cola estática (en una tabla)
        • 3.3.1 Estructura de datos
        • 3.3.2 Cola vacía, cola llena
        • 3.3.3 Inicialización
        • 3.3.4 Encolar
        • 3.3.5 Obtener el primero, obtener el último
        • 3.3.6 Avanzar
        • 3.3.7 Vaciar, destruir
        • 3.3.8 Mostrar
        • 3.3.9 Prueba en el main()
      • 3.4 Puesta en práctica: colas
    • 4. Árboles
      • 4.1 Generalidades sobre los árboles
        • 4.1.1 Principio
        • 4.1.2 Ejemplos de uso de árboles
        • 4.1.3 Nomenclatura de los árboles
      • 4.2 Tipos de árbol
        • 4.2.1 Árbol binario
        • 4.2.2 Árbol n-ario
        • 4.2.3 Transformar un árbol n-ario en árbol binario
      • 4.3 Representaciones en memoria
        • 4.3.1 Árbol n-ario
        • 4.3.2 Árbol binario
        • 4.3.3 Estructuras de datos estáticas o dinámicas
    • 5. Controlar un árbol binario
      • 5.1 Crear un árbol binario
        • 5.1.1 Crear un árbol a partir de un esquema descriptivo
        • 5.1.2 Crear un árbol a partir de los datos aleatorios de una tabla
        • 5.1.3 Crear un árbol insertando elementos ordenados
      • 5.2 Recorrer un árbol
        • 5.2.1 Recorrido en profundidad
        • 5.2.2 Recorrido en amplitud, por niveles
      • 5.3 Mostrar el árbol
        • 5.3.1 Mostrar un árbol con indentación
        • 5.3.2 Dibujar el árbol sin los enlaces
      • 5.4 Obtener propiedades de un árbol binario
        • 5.4.1 Averiguar el tamaño
        • 5.4.2 Averiguar la altura
        • 5.4.3 Averiguar si un nodo es una hoja
        • 5.4.4 Contar el número de hojas de un árbol
        • 5.4.5 Listar todas las hojas
        • 5.4.6 Calcular la suma de valores de los nodos
        • 5.4.7 Comparar valores de los nodos del árbol
        • 5.4.8 Obtener un nodo del árbol a partir de un valor
      • 5.5 Clonar el árbol
      • 5.6 Destruir el árbol
      • 5.7 Conversión estática-dinámica de un árbol binario
        • 5.7.1 Conversión de un árbol estático a uno dinámico
        • 5.7.2 Conversión de un árbol dinámico a uno estático
      • 5.8 Guardar y cargar un árbol binario
        • 5.8.1 Guardar un árbol dinámico
        • 5.8.2 Cargar un árbol dinámico
      • 5.9 Árboles binarios en archivos
        • 5.9.1 Estructura de datos
        • 5.9.2 Lectura de un nodo a partir de su número de registro
        • 5.9.3 Adaptación de las funciones para árboles dinámicos o estáticos
      • 5.10 Puesta en práctica: árbol binario
    • 6. Árboles binarios de búsqueda
      • 6.1 Definición
      • 6.2 Estructura de datos
      • 6.3 Insertar un elemento en el árbol según su clave
        • 6.3.1 Comparar dos claves
        • 6.3.2 Insertar un elemento en la ubicación correcta
      • 6.4 Buscar en un árbol un elemento según su clave
      • 6.5 Eliminar un elemento del árbol de búsqueda
        • 6.5.1 Tres casos
        • 6.5.2 Función de búsqueda del nodo mayor
        • 6.5.3 Función de borrado
      • 6.6 Listar todos los elementos del árbol (recorrido en amplitud)
      • 6.7 Mostrar el árbol
      • 6.8 Prueba en el main()
      • 6.9 Puesta en práctica: árboles
  • Variables objeto, descubrir C++
    • 1. C incluido en C++
      • 1.1 Un proyecto de consola en C++
        • 1.1.1 Librería <iostream>
        • 1.1.2 La instrucción using namespace std;
      • 1.2 Un programa C compilado en C++
    • 2. C aumentado en C++
      • 2.1 Entrada-salida en consola: cout y cin
        • 2.1.1 Utilizar cout y cin
        • 2.1.2 Instrucciones de formato en salida
      • 2.2 Variables y constantes
        • 2.2.1 Declaraciones más ágiles
        • 2.2.2 Tipo bool
        • 2.2.3 Tipo de carácter unicode: wchar_t
        • 2.2.4 Typedef inútil para tuplas
        • 2.2.5 Tipo referencia (puntero oculto)
        • 2.2.6 Tipo puntero, operadores new y delete
        • 2.2.7 Constantes y punteros
        • 2.2.8 Constantes (const) y enumeración (enum) mejor que #define
      • 2.3 Conversiones de tipos
        • 2.3.1 static_cast<tipo>
        • 2.3.2 const_cast<tipo>
        • 2.3.3 reinterpret_cast<tipo>
        • 2.3.4 dynamic_cast<tipo>
      • 2.4 Funciones
        • 2.4.1 Funciones declaradas «inline»
        • 2.4.2 Devolver una referencia
        • 2.4.3 Sobrecarga de funciones
        • 2.4.4 Valores por defecto en parámetros
        • 2.4.5 Funciones genéricas (template)
        • 2.4.6 Funciones como campos de tuplas
      • 2.5 Gestión de excepciones (básica)
        • 2.5.1 Instrucción throw
        • 2.5.2 Instrucción de salto try-catch
        • 2.5.3 Instrucción throw y llamadas de funciones
        • 2.5.4 Instrucción throw sin valor de retorno
        • 2.5.5 Especificar qué excepciones lanzan las funciones
        • 2.5.6 Excepción no identificada
        • 2.5.7 Bloque catch(...) por defecto
      • 2.6 Espacios de nombres (namespace) y atajos (using)
      • 2.7 Integrar otros lenguajes en el código C++
    • 3. El paradigma de la programación orientada a objetos de C++
      • 3.1 Clase y objeto
        • 3.1.1 ¿ Qué es una clase ?
        • 3.1.2 ¿ Qué es un objeto ?
        • 3.1.3 Definir una clase
        • 3.1.4 Declarar un objeto
        • 3.1.5 Permisos de acceso
        • 3.1.6 Un programa C mutado a clase y objeto
      • 3.2 Constructor
        • 3.2.1 Parametrizar un objeto en su declaración
        • 3.2.2 El puntero this
        • 3.2.3 Constructor sin parámetros
        • 3.2.4 Constructores con parámetros
        • 3.2.5 Constructor y copia de objetos
        • 3.2.6 Constructor con conversión
      • 3.3 Destructor
      • 3.4 Clases y miembros «static»
        • 3.4.1 Calificativo static en C
        • 3.4.2 Calificativo static y objetos
      • 3.5 Sobrecarga de operadores
        • 3.5.1 Función operator global fuera de la clase
        • 3.5.2 Función operator localizada en una clase
        • 3.5.3 Función operator y datos dinámicos
      • 3.6 Clases genéricas («template»)
        • 3.6.1 Principio
        • 3.6.2 Sintaxis básica
        • 3.6.3 Sintaxis de los constructores
        • 3.6.4 Sintaxis con varios tipos genéricos
        • 3.6.5 Ejemplo de implementación de una pila genérica
        • 3.6.6 Especialización de una función para un tipo concreto
      • 3.7 Herencia
        • 3.7.1 Definir una clase derivada
        • 3.7.2 Llamar explícitamente a un constructor de la clase base
        • 3.7.3 Redefinición de atributos o de métodos
        • 3.7.4 Especificar un miembro de la clase base
        • 3.7.5 Permisos de acceso de la clase heredada
        • 3.7.6 Herencia múltiple
        • 3.7.7 Herencia múltiple con una base virtual
      • 3.8 Punteros polimórficos, virtualidad
        • 3.8.1 Acceso a punteros por defecto en funciones redefinidas
        • 3.8.2 Acceso con puntero a métodos virtuales redefinidos
        • 3.8.3 Lo interesante del acceso mediante punteros a métodos virtuales
        • 3.8.4 Clases abstractas, funciones virtuales puras
      • 3.9 Clases y funciones «amigas» (friend)
  • Anexo
    • 1. Prioridad y asociatividad de operadores
    • 2. Algunas herramientas de visualización en consola de Windows
    • 3. Librería C de creación en modo consola
      • 3.1 Descarga
      • 3.2 Instalación
      • 3.3 Uso
      • 3.4 Funciones disponibles
        • 3.4.1 Manejar el cursor en escritura
        • 3.4.2 Manejar el color
        • 3.4.3 Algunas operaciones en la ventana de consola
        • 3.4.4 Gestión de eventos
        • 3.4.5 CHBITMAP: buffer de datos para visualización
        • 3.4.6 CHTEXT: operaciones de texto en modo CHBITMAP
    • índice

Autor

Frédéric DROUILLONMás información

Características

  • Nivel Medio a Experto
  • Número de páginas 604 páginas
  • Publicación diciembre 2012
    • Encuadernación rústica - 17 x 21 cm
    • ISBN: 978-2-7460-0784-4
    • EAN: 9782746078444
    • Ref. ENI: RITCC
  • Nivel Iniciado a Medio
  • Publicación diciembre 2012
    • HTML
    • ISBN: 978-2-7460-0784-2
    • EAN: 9782746078482
    • Ref. ENI: LNRITCC

Descargas

Al completar este formulario, acepta recibir información y comunicaciones comerciales sobre nuestros productos y servicios. Puede darse de baja de nuestra newsletter en cualquier momento. Si desea conocer más información acerca de nuestra política de protección de datos, pulse aquí.
  • Descargar los ejemplos del libro (Archivos-complementarios) - 137 Ko
  • Descargar los ejemplos del libro (Archivos-de-correcciones) - 134 Ko
  • Webs referenciadas