Español | 47.1 Mb | Pdf | Autor: Walter Savitch | Segunda Edición | Páginas: 948 | Pass:www.detodoprogramacion.org
Descripción:
Este libro se diseñó para utilizarse en un primer curso de programación y ciencias de la computación usando el lenguaje C++. No se requiere experiencia previa en programación ni conocimientos de matemáticas más allá del álgebra de educación media. También podría emplearse como texto de un curso diseñado para enseñar C++ a estudiantes que ya han llevado algún otro curso de programación, en cuyo caso los primeros capítulos pueden dejarse simplemente como repaso en casa.
Si ya utilizó la primera edición de este libro, le recomiendo que lea la siguiente sección, que explica los cambios realizados en esta segunda edición, y que se salte el resto del prefacio. Si es la primera vez que usa este libro, el resto del prefacio le ofrecerá un panorama general.
Cambios en la segunda edición
Esta segunda edición presenta la misma filosofía de programación y cubre los mismos temas que la primera edición. Si usted es un profesor que está usando la primera edición, puede seguir impartiendo su curso casi sin modificaciones. Sin embargo, esta segunda edición ofrece la oportunidad de añadir temas de interés al curso. Además incluye ejercicios adicionales, presenta algunas secciones de forma más clara y correcta e introduce algunos temas nuevos muy importantes. Los principales temas añadidos son el uso del tipo bool para valores booleanos, la clase string de la STL (biblioteca de plantillas estándar) y un capítulo final sobre herencia. El uso del tipo bool se ha integrado en todo el libro. Si está usando un compilador que todavía no reconoce dicho tipo, el apéndice 10 le explica cómo puede simularlo fácilmente en su sistema. Tanto el uso de la clase string de la STL como el material adicional sobre herencia se pueden considerar como opcionales. Sin embargo, le recomiendo considerar la inclusión de alguno de estos temas, o de ambos, en su curso.
Existen por lo menos dos formas de introducir las clases en una fase temprana de un libro. Desde un principio se puede enseñar a los estudiantes a diseñar sus propias clases, o simplemente a usarlas sin definirlas. Este libro en su fase inicial enseña a los estudiantes a definir sus propias clases, no sólo a usarlas. Para poder diseñar clases de forma
eficaz, el estudiante necesita algunas herramientas básicas, como estructuras de control simples y definiciones de funciones. Por ello, el libro cubre estos fundamentos en los capítulos 2, 3 y 4, y luego pasa inmediatamente a las clases. En el capítulo 5 se utilizan los flujos de archivo de E/S para enseñar a los estudiantes la forma de usar clases. En el capítulo 6 los estudiantes aprenden a escribir sus propias clases.
Este libro adopta un enfoque gradual para cubrir las clases. Primero enseña a los estudiantes a escribir clases muy sencillas, luego se añaden constructores, luego se muestra la sobrecarga de operadores simples, luego la sobrecarga de los operadores de E/S << y >>, y así sucesivamente. Este enfoque gradual evita que el estudiante se sienta abrumado por una larga lista de construcciones y conceptos complicados. Sin embargo, un objetivo de este libro es lograr que los estudiantes escriban lo antes posible definiciones de clases realistas, sin pasar mucho tiempo escribiendo clases artificialmente sencillas.
Para cuando terminen el capítulo 8, los estudiantes estarán escribiendo básicamente los mismos tipos de clases que escribirán cuando terminen el curso. Hay unos cuantos temas relacionados con las clases que no se introducen desde un principio. Éstos incluyen destructores, plantillas y uso avanzado de la herencia. Los destructores se introducen hasta después de haber cubierto las estructuras de datos dinámicas. Introducirlos antes no tendría caso, ya que no servirían de nada. Las plantillas no se introducen en una fase temprana por tres razones. Primera, muchos compiladores todavía no las manejan debidamente. Con varios compiladores, las plantillas de clase requieren un cuidado especial si se compilan aparte. Con frecuencia, la compilación de plantillas de clase está sujeta a restricciones que hacen poco práctico
compilarlas por separado. Segunda, una plantilla es un esquema que genera muchas clases que no son de plantilla. Por lo tanto, antes de poder entender qué es una plantilla de clase, es necesario saber qué son las clases que no son de plantilla. Una vez que el estudiante se siente cómodo con las clases que no son de plantilla, las plantillas de clase son una generalización fácil y natural. Tercera, muchos de los ejemplos en que es más provechoso el uso de plantillas se refieren a estructuras de datos, como pilas y colas, que normalmente sólo se cubren en un segundo curso de programación. Sin embargo, si el profesor desea cubrir las plantillas antes, el material correspondiente se escribió de forma que se pueda impartir en una fase más temprana del curso.
La herencia se cubre brevemente en el capítulo 5 con el fin de que los estudiantes estén conscientes del concepto. Sin embargo, este libro no enseña a los estudiantes a escribir sus propias clases derivadas sino hasta el capítulo final.
La razón es que los ejemplos que motivan fuertemente el uso de la herencia y las clases derivadas no surgen naturalmente al principio de un primer curso. Podríamos tratar de introducir ejemplos que usen clases derivadas antes en un primer curso, pero para los estudiantes es difícil sacar provecho realista de las clases derivadas antes de adquirir más experiencia en programación.
Estos temas más avanzados fácilmente se pueden introducir más adelante, e incluso sin estos temas los estudiantes tendrán un concepto refinado y realista de las clases. El capítulo 15 enseña a definir y utilizar clases derivadas, e incluye el uso de funciones virtuales. Algunos profesores podrían optar por dejar ese material para un segundo curso, pero otros necesitarán integrar a su curso esta cobertura de la herencia.
Aunque posponemos el tratamiento de los destructores, las plantillas y casi todo lo relativo a la herencia, las clases que se usan desde un principio en el libro son refinadas, y algunos podrían alegar que son demasiado complicadas para cubrirse en una fase tan temprana de un primer curso de programación.
Después de todo, además de los conceptos básicos de variables miembro y funciones miembro, los estudiantes principiantes que lean este libro aprenderán los siguientes temas en una fase muy temprana: miembros públicos y privados, sobrecarga de funciones, sobrecarga de operadores, funciones friend, devolución de una referencia para poder sobrecargar los operadores de E/S << y>>, constructores para inicialización automática, constructores para conversión de tipos, y varias cuestiones menores. Algunos podrían pensar que ésta es una dosis excesiva de material nuevo. Sin embargo, hemos probado este material en las aulas y hemos comprobado que si omitimos cualquiera de estos temas, los ejemplos se vuelven artificialmente sencillos y mal comportados. Además, en las pruebas efectuadas en las aulas vimos que los estudiantes responden a la introducción temprana de las clases básicamente de la misma forma que responden a la introducción temprana de las funciones. Sin duda, el material presenta algunos problemas, pero los estudiantes son tan capaces de aprenderlo en una fase temprana del curso como en una etapa posterior. Además, la cobertura tempraqa de las clases hace que los estudiantes adquieran conocimientos prácticos más firmes de este tema, pues tienen una fuerte lealtad a la primera técnica que aprenden para resolver un problema. Por lo tanto, si queremos que usen realmente una técnica, debemos enseñarla pronto. Por otra parte, las clases no son el tema más difícil con que se toparán. Por ejemplo, las clases son más intuitivas y mejor comportadas que los arreglos ordinarios (al estilo C), que se aprenden en una fase posterior del curso.
Contenido:
Capítulo 1. Introducción a las computadoras y a la programación en C++
Capítulo 2. Fundamentos de C++
Capítulo 3. Abstracción de procedimientos y funciones que devuelven un valor
Capítulo 4. Funciones para todas las subtareas
Capítulo 5. Flujos de E/S como introducción a los objetos y clases
Capítulo 6. Definición de clases y de tipos de datos abstractos
Capítulo 7. Más flujo de control
Capítulo 8. Herramientas para definir tipos de datos abstractos
Capítulo 9. Arreglos
Capítulo 10. Cadenas y arreglos multidimensionales
Capítulo 11. Apuntadores y arreglos dinámicos
Capítulo 12. Recursión
Capítulo 13. Plantillas para lograr mayor abstracción
Capítulo 14. Apuntadores y listas enlazadas
Capítulo 15. Herencia
No hay comentarios:
Publicar un comentario