Programación imperativa

Fortran (1958) se presentó como "El sistema de traducción de fórmulas matemáticas de IBM". Fue diseñado para cálculos científicos, sin funciones de manejo de cadenas . Además de declaraciones , expresiones y sentencias , admitía:

• matrices
• subrutinas
• bucles "do"

Tuvo éxito porque:

• Los costos de programación y depuración fueron inferiores a los costos de funcionamiento de la computadora.
• Contó con el apoyo de IBM.
• Las aplicaciones en ese momento eran científicas. ^{[ 3 ]}

Sin embargo, otros proveedores que no eran de IBM también escribieron compiladores de Fortran, pero con una sintaxis que probablemente no sería compatible con el compilador de IBM. ^{[ 3 ]} El Instituto Nacional Estadounidense de Estándares (ANSI) desarrolló el primer estándar de Fortran en 1966. En 1978, Fortran 77 se convirtió en el estándar hasta 1991. Fortran 90 admite:

• archivos
• punteros a matrices

COBOL (1959) significa "Lenguaje Común Orientado a los Negocios". Fortran manipulaba símbolos. Pronto se comprendió que los símbolos no tenían por qué ser números, por lo que se introdujeron las cadenas de caracteres. ^{[ 4 ]} El Departamento de Defensa de los Estados Unidos influyó en el desarrollo de COBOL, siendo Grace Hopper una de las principales contribuyentes. Las sentencias eran similares al inglés y prolijas. El objetivo era diseñar un lenguaje que los gerentes pudieran leer. Sin embargo, la falta de sentencias estructuradas dificultó este objetivo. ^{[ 5 ]}

El desarrollo de COBOL estuvo estrictamente controlado, por lo que no surgieron dialectos que requirieran estándares ANSI. En consecuencia, no se modificó durante 15 años, hasta 1974. La versión de la década de 1990 introdujo cambios importantes, como la programación orientada a objetos . ^{[ 5 ]}

ALGOL (1960) significa "Lenguaje ALGOrítmico". Tuvo una profunda influencia en el diseño de lenguajes de programación. ^{[ 6 ]} Surgió de un comité de expertos europeos y estadounidenses en lenguajes de programación, utilizó notación matemática estándar y tenía un diseño estructurado y legible. ALGOL fue el primero en definir su sintaxis utilizando la forma Backus-Naur . ^{[ 6 ]} Esto dio lugar a compiladores dirigidos por sintaxis . Añadió características como:

• estructura de bloques, donde las variables eran locales a su bloque
• matrices con límites variables
• bucles "for"
• funciones
• recursión ^{[ 6 ]}

Entre los descendientes directos de ALGOL se encuentran Pascal , Modula-2 , Ada , Delphi y Oberon en una rama. En otra rama están C , C++ y Java . ^{[ 6 ]}

BASIC (1964) significa "Código de Instrucción Simbólica de Propósito General para Principiantes". Fue desarrollado en el Dartmouth College para que todos sus estudiantes lo aprendieran. ^{[ 7 ]} Si un estudiante no continuaba con un lenguaje más potente, aún recordaría BASIC. ^{[ 7 ]} Se instaló un intérprete de BASIC en las microcomputadoras fabricadas a finales de la década de 1970. A medida que crecía la industria de las microcomputadoras, también lo hacía el lenguaje. ^{[ 7 ]}

BASIC fue pionero en la sesión interactiva . ^{[ 7 ]} Ofrecía comandos del sistema operativo dentro de su entorno:

• El comando 'new' creó un lienzo en blanco.
• Declaraciones evaluadas de inmediato
• Las instrucciones podrían programarse anteponiéndoles un número de línea.
• El comando 'list' mostró el programa.
• El comando 'run' ejecutó el programa.

Sin embargo, la sintaxis de BASIC era demasiado simple para programas grandes. ^{[ 7 ]} Los dialectos más recientes añadieron estructura y extensiones orientadas a objetos. Visual Basic de Microsoft sigue siendo ampliamente utilizado y produce una interfaz gráfica de usuario . ^{[ 8 ]}

El lenguaje de programación C (1973) recibió su nombre porque el lenguaje BCPL fue reemplazado por B , y AT&T Bell Labs llamó a la siguiente versión "C". Su propósito era escribir el sistema operativo UNIX . ^{[ 9 ]} C es un lenguaje relativamente pequeño, lo que facilita la escritura de compiladores. Su crecimiento reflejó el crecimiento del hardware en la década de 1980. ^{[ 9 ]} Su crecimiento también se debió a que posee las facilidades del lenguaje ensamblador , pero utiliza una sintaxis de alto nivel . Añadió características avanzadas como:

• ensamblador en línea
• aritmética con punteros
• punteros a funciones
• operaciones de bits
• Combinación libre de operadores complejos ^{[ 9 ]}

C permite al programador controlar en qué región de la memoria se almacenarán los datos. Las variables globales y estáticas requieren la menor cantidad de ciclos de reloj para su almacenamiento. La pila se utiliza automáticamente para las declaraciones de variables estándar . La memoria del montón se devuelve a una variable de puntero desde la malloc()función.

• La región de datos global y estático se encuentra justo encima de la región del programa . (Técnicamente, la región del programa se denomina región de texto . Es donde se almacenan las instrucciones de la máquina).
  • La región de datos global y estática es técnicamente dos regiones. ^{[ 10 ]} Una región se llama segmento de datos inicializados , donde se almacenan las variables declaradas con valores predeterminados. La otra región se llama segmento de bloque iniciado por , donde se almacenan las variables declaradas sin valores predeterminados.
  • Las variables almacenadas en la región de datos globales y estáticos tienen sus direcciones definidas en tiempo de compilación. Conservan sus valores durante toda la vida del proceso.
  • La región global y estática almacena las variables globales que se declaran encima (fuera) de la main()función. ^{[ 11 ]} Las variables globales son visibles para main()y todas las demás funciones en el código fuente.
• Por otro lado, las declaraciones de variables dentro de main()otras funciones o dentro {}de delimitadores de bloque son variables locales . Las variables locales también incluyen variables de parámetros formales . Las variables de parámetros están encerradas entre paréntesis en las definiciones de funciones. ^{[ 12 ]} Proporcionan una interfaz a la función.
  • Las variables locales declaradas usando el staticprefijo también se almacenan en la región de datos global y estático . ^{[ 10 ]} A diferencia de las variables globales, las variables estáticas solo son visibles dentro de la función o bloque. Las variables estáticas siempre conservan su valor. Un ejemplo de uso sería la función

    int increment_counter () { static int counter = 0 ; counter ++ ; return counter ; }

• La región de pila es un bloque contiguo de memoria ubicado cerca de la dirección de memoria superior. ^{[ 13 ]} Las variables colocadas en la pila se llenan de arriba a abajo. ^{[ 13 ]} Un puntero de pila es un registro especial que mantiene un registro de la última dirección de memoria llenada. ^{[ 13 ]} Las variables se colocan en la pila mediante la instrucción PUSH del lenguaje ensamblador . Por lo tanto, las direcciones de estas variables se establecen durante el tiempo de ejecución . El método para que las variables de pila pierdan su ámbito es mediante la instrucción POP.
  • Las variables locales declaradas sin el staticprefijo, incluidas las variables de parámetros formales, ^{[ 14 ]} se denominan variables automáticas ^{[ 11 ]} y se almacenan en la pila. ^{[ 10 ]} Son visibles dentro de la función o bloque y pierden su ámbito al salir de la función o bloque.
  • La región de memoria dinámica (heap) se encuentra debajo de la pila. ^{[ 10 ]} Se llena de abajo hacia arriba. El sistema operativo administra la memoria dinámica mediante un puntero a memoria dinámica y una lista de bloques de memoria asignados. ^{[ 15 ]} Al igual que la pila, las direcciones de las variables de memoria dinámica se establecen durante la ejecución. Se produce un error de falta de memoria cuando el puntero a memoria dinámica y el puntero a pila coinciden.
  • C proporciona la malloc()función de biblioteca para asignar memoria dinámica (heap). ^{[ 16 ]} El llenado del heap con datos es una función de copia adicional. Las variables almacenadas en el heap se pasan de forma eficiente a las funciones mediante punteros. Sin punteros, todo el bloque de datos tendría que pasarse a la función a través de la pila.

En la década de 1970, los ingenieros de software necesitaban soporte de lenguaje para dividir grandes proyectos en módulos . ^{[ 17 ]} Una característica obvia era descomponer físicamente los grandes proyectos en archivos separados . Una característica menos obvia era descomponer lógicamente los grandes proyectos en tipos de datos abstractos . ^{[ 17 ]} En ese momento, los lenguajes admitían tipos de datos concretos ( escalares ) como números enteros , números de punto flotante y cadenas de caracteres . Los tipos de datos concretos tienen su representación como parte de su nombre. ^{[ 18 ]} Los tipos de datos abstractos son estructuras de tipos de datos concretos, con un nuevo nombre asignado. Por ejemplo, una lista de enteros podría llamarse .integer_list

En la jerga de la programación orientada a objetos, los tipos de datos abstractos se denominan clases . Sin embargo, una clase es solo una definición; no se le asigna memoria. Cuando se le asigna memoria a una clase, se la denomina objeto . ^{[ 19 ]}

Los lenguajes imperativos orientados a objetos se desarrollaron combinando la necesidad de clases y la necesidad de una programación funcional segura . ^{[ 20 ]} En un lenguaje orientado a objetos, una función se asigna a una clase. Una función asignada se denomina método , función miembro u operación . La programación orientada a objetos consiste en ejecutar operaciones sobre objetos . ^{[ 21 ]}

Los lenguajes orientados a objetos admiten una sintaxis para modelar relaciones de subconjunto/superconjunto . En la teoría de conjuntos , un elemento de un subconjunto hereda todos los atributos contenidos en el superconjunto. Por ejemplo, un estudiante es una persona. Por lo tanto, el conjunto de estudiantes es un subconjunto del conjunto de personas. Como resultado, los estudiantes heredan todos los atributos comunes a todas las personas. Además, los estudiantes tienen atributos únicos que otras personas no tienen. Los lenguajes orientados a objetos modelan las relaciones de subconjunto/superconjunto mediante la herencia . ^{[ 22 ]} La programación orientada a objetos se convirtió en el paradigma de lenguaje dominante a finales de la década de 1990. ^{[ 17 ]}

C++ (1985) se llamó originalmente "C con clases". ^{[ 23 ]} Fue diseñado para ampliar las capacidades de C añadiendo las funcionalidades orientadas a objetos del lenguaje Simula . ^{[ 24 ]}

Un módulo orientado a objetos se compone de dos archivos. El archivo de definiciones se denomina archivo de cabecera . Aquí se muestra un archivo de cabecera de C++ para la clase GRADE en una aplicación escolar sencilla:

// grade.h // -------// Se utiliza para permitir que varios archivos fuente incluyan // este archivo de encabezado sin errores de duplicación. // Véase: https://en.wikipedia.org/wiki/Include_guard // ---------------------------------------------- #ifndef GRADE_H #define GRADE_Hclase GRADE { public : // Esta es la operación del constructor. // ---------------------------------- GRADE ( const char letter );// Esta es una variable de clase. // ------------------------- char letra ;// Esta es una operación miembro. // --------------------------- int grade_numeric ( const char letter );// Esta es una variable de clase. // ------------------------- int numeric ; }; #endif

Una operación constructora es una función con el mismo nombre que el nombre de la clase. ^{[ 25 ]} Se ejecuta cuando la operación que la llama ejecuta la newinstrucción.

El otro archivo de un módulo es el archivo fuente . Aquí hay un archivo fuente de C++ para la clase GRADE en una aplicación escolar simple:

// grade.cpp // --------- #include "grade.h"CALIFICACIÓN :: CALIFICACIÓN ( const char letra ) { // Referencia el objeto usando la palabra clave 'this'. // ---------------------------------------------- this -> letra = letra ;// Esto es cohesión temporal // ------------------------- this -> numeric = grade_numeric ( letter ); }int GRADE :: grade_numeric ( const char letter ) { if ( ( letter == 'A' || letter == 'a' ) ) return 4 ; else if ( ( letter == 'B' || letter == 'b' ) ) return 3 ; else if ( ( letter == 'C' || letter == 'c' ) ) return 2 ; else if ( ( letter == 'D' || letter == 'd' ) ) return 1 ; else if ( ( letter == 'F' || letter == 'f' ) ) return 0 ; else return -1 ; }

Aquí tenéis un archivo de cabecera de C++ para la clase PERSON en una sencilla aplicación escolar:

// person.h // -------- #ifndef PERSON_H #define PERSON_Hclase PERSONA { público : PERSONA ( const char * nombre ); const char * nombre ; }; #endif

Aquí tenéis un archivo fuente en C++ para la clase PERSONA en una sencilla aplicación escolar:

// person.cpp // ---------- #include "person.h"PERSONA :: PERSONA ( const char * nombre ) { this -> nombre = nombre ; }

Aquí tenéis un archivo de cabecera de C++ para la clase ESTUDIANTE en una sencilla aplicación escolar:

// student.h // --------- #ifndef ESTUDIANTE_H #define ESTUDIANTE_H#incluir "persona.h" #incluir "grado.h"// Un ESTUDIANTE es un subconjunto de PERSONA. // -------------------------------- class ESTUDIANTE : public PERSONA { public : ESTUDIANTE ( const char * nombre ); ~ ESTUDIANTE (); CALIFICACIÓN * calificación ; }; #endif

Aquí tenéis un archivo fuente de C++ para la clase ESTUDIANTE en una sencilla aplicación escolar:

// student.cpp // ----------- #include "student.h" #include "person.h"ESTUDIANTE :: ESTUDIANTE ( const char * nombre ) : // Ejecuta el constructor de la superclase PERSONA. // ------------------------------------------------- PERSONA ( nombre ) { // No hay nada más que hacer. // ------------------- }ESTUDIANTE ::~ ESTUDIANTE () { // liberar la memoria de la calificación // para evitar fugas de memoria. // ------------------------------------------------- eliminar esto -> calificación ; }

Aquí hay un programa de controlador a modo de demostración:

// student_dvr.cpp // --------------- #include <iostream> #include "student.h"int main ( void ) { ESTUDIANTE * estudiante = nuevo ESTUDIANTE ( "El estudiante" ); estudiante -> calificación = nuevo CALIFICACIÓN ( 'a' );std :: cout // Observe que el estudiante hereda el nombre de PERSONA << estudiante- > nombre << ": Calificación numérica = " << estudiante- > calificación- > numérico << " \n " ;// liberar la memoria del estudiante // para evitar fugas de memoria. // ------------------------------------------------- eliminar estudiante ;devolver 0 ; }

Aquí tenéis un archivo makefile para compilarlo todo:

# makefile # -------- all : student_dvrlimpiar : rm student_dvr *.o student_dvr : student_dvr.cpp grade.o student.o person.o c ++ student_dvr.cpp grade.o student.o person.o -o student_dvr​​​​​​​grade.o : grade . cpp grade . h c++ -c grade.cppestudiante.o : estudiante.cpp estudiante.h c ++ -c estudiante.cpp​​​persona.o : persona . cpp persona . h c++ -c persona.cpp