En informática , la programación imperativa es un paradigma de programación de software que utiliza declaraciones que cambian el estado de un programa . De la misma manera que el modo imperativo en los lenguajes naturales expresa órdenes, un programa imperativo consta de órdenes que debe ejecutar la computadora . La programación imperativa se centra en describir cómo funciona un programa paso a paso, [1] en lugar de descripciones de alto nivel de sus resultados esperados.
El término se utiliza a menudo en contraste con la programación declarativa , que se centra en lo que el programa debería lograr sin especificar todos los detalles de cómo el programa debería lograr el resultado. [2]
La programación procesal es un tipo de programación imperativa en la que el programa se construye a partir de uno o más procedimientos (también denominados subrutinas o funciones). Los términos se utilizan a menudo como sinónimos, pero el uso de procedimientos tiene un efecto dramático en cómo aparecen los programas imperativos y cómo se construyen. La programación procesal intensa, en la que los cambios de estado se localizan en procedimientos o se restringen a argumentos explícitos y resultados de procedimientos, es una forma de programación estructurada . Desde la década de 1960, la programación estructurada y la programación modular en general se han promovido como técnicas para mejorar la mantenibilidad y la calidad general de los programas imperativos. Los conceptos detrás de la programación orientada a objetos intentan ampliar este enfoque.
La programación procesal podría considerarse un paso hacia la programación declarativa. Un programador a menudo puede decir, simplemente mirando los nombres, argumentos y tipos de procedimientos devueltos (y comentarios relacionados), qué se supone que debe hacer un procedimiento en particular, sin necesariamente mirar los detalles de cómo logra su resultado. Al mismo tiempo, un programa completo sigue siendo imperativo ya que fija en gran medida las sentencias a ejecutar y su orden de ejecución.
El paradigma de programación utilizado para crear programas para casi todas las computadoras suele seguir un modelo imperativo. [nota 1] El hardware de computadora digital está diseñado para ejecutar código de máquina , que es nativo de la computadora y generalmente está escrito en estilo imperativo, aunque existen compiladores e intérpretes de bajo nivel que utilizan otros paradigmas para algunas arquitecturas, como las máquinas lisp .
Desde esta perspectiva de bajo nivel, el estado del programa está definido por el contenido de la memoria y las declaraciones son instrucciones en el lenguaje de máquina nativo de la computadora. Los lenguajes imperativos de nivel superior utilizan variables y declaraciones más complejas, pero siguen el mismo paradigma. Las recetas y las listas de verificación de procesos , aunque no son programas de computadora , también son conceptos familiares que tienen un estilo similar a la programación imperativa; cada paso es una instrucción, y el mundo físico mantiene el estado. Dado que las ideas básicas de la programación imperativa son conceptualmente familiares y están directamente incorporadas en el hardware, la mayoría de los lenguajes informáticos son de estilo imperativo.
Las declaraciones de asignación , en el paradigma imperativo, realizan una operación sobre información ubicada en la memoria y almacenan los resultados en la memoria para su uso posterior. Los lenguajes imperativos de alto nivel, además, permiten la evaluación de expresiones complejas , que pueden consistir en una combinación de operaciones aritméticas y evaluaciones de funciones , y la asignación del valor resultante a la memoria. Las sentencias en bucle (como en los bucles while , do while y for ) permiten que una secuencia de sentencias se ejecute varias veces. Los bucles pueden ejecutar las declaraciones que contienen un número predefinido de veces o pueden ejecutarlas repetidamente hasta que se cumpla alguna condición. Las declaraciones de bifurcación condicional permiten ejecutar una secuencia de declaraciones solo si se cumple alguna condición. De lo contrario, las declaraciones se omiten y la secuencia de ejecución continúa a partir de la declaración que las sigue. Las declaraciones de bifurcación incondicionales permiten transferir una secuencia de ejecución a otra parte de un programa. Estos incluyen el salto (llamado ir a en muchos idiomas), cambiar y el subprograma, subrutina o llamada a procedimiento (que generalmente regresa a la siguiente declaración después de la llamada).
Al principio del desarrollo de los lenguajes de programación de alto nivel , la introducción del bloque permitió la construcción de programas en los que un grupo de sentencias y declaraciones podían tratarse como si fueran una sola sentencia. Esto, junto con la introducción de subrutinas , permitió expresar estructuras complejas mediante descomposición jerárquica en estructuras procesales más simples.
Muchos lenguajes de programación imperativos (como Fortran , BASIC y C ) son abstracciones del lenguaje ensamblador . [3]
Los primeros lenguajes imperativos fueron los lenguajes de máquina de las computadoras originales. En estos lenguajes las instrucciones eran muy sencillas, lo que facilitaba la implementación del hardware pero dificultaba la creación de programas complejos. FORTRAN , desarrollado por John Backus en International Business Machines (IBM) a partir de 1954, fue el primer lenguaje de programación importante que eliminó los obstáculos que presentaba el código de máquina en la creación de programas complejos. FORTRAN era un lenguaje compilado que permitía variables con nombre, expresiones complejas, subprogramas y muchas otras características que ahora son comunes en los lenguajes imperativos. Las siguientes dos décadas vieron el desarrollo de muchos otros importantes lenguajes de programación imperativos de alto nivel. A finales de los años 1950 y 1960, ALGOL se desarrolló para permitir que los algoritmos matemáticos se expresaran más fácilmente e incluso sirvió como lenguaje de destino del sistema operativo para algunas computadoras. MUMPS (1966) llevó el paradigma imperativo a un extremo lógico, al no tener ninguna declaración en absoluto, confiando exclusivamente en comandos, incluso hasta el punto de hacer que los comandos IF y ELSE sean independientes entre sí, conectados sólo por una variable intrínseca llamada $ PRUEBA. COBOL (1960) y BASIC (1964) fueron intentos de hacer que la sintaxis de programación se pareciera más al inglés. En la década de 1970, Pascal fue desarrollado por Niklaus Wirth y C fue creado por Dennis Ritchie mientras trabajaba en Bell Laboratories . Wirth pasó a diseñar Modula-2 y Oberon . Para las necesidades del Departamento de Defensa de los Estados Unidos , Jean Ichbiah y un equipo de Honeywell comenzaron a diseñar Ada en 1978, después de un proyecto de 4 años para definir los requisitos del lenguaje. La especificación se publicó por primera vez en 1983, con revisiones en 1995, 2005 y 2012.
La década de 1980 vio un rápido crecimiento en el interés por la programación orientada a objetos . Estos lenguajes eran imperativos en estilo, pero agregaban características para soportar objetos . Las dos últimas décadas del siglo XX vieron el desarrollo de muchos de estos idiomas. Smalltalk -80, concebido originalmente por Alan Kay en 1969, fue lanzado en 1980 por el Centro de Investigación Xerox Palo Alto ( PARC ). A partir de conceptos de otro lenguaje orientado a objetos, Simula ( que se considera el primer lenguaje de programación orientado a objetos del mundo , desarrollado en la década de 1960), Bjarne Stroustrup diseñó C++ , un lenguaje orientado a objetos basado en C. El diseño de C++ comenzó en 1979 y la primera implementación se completó en 1983. A finales de los años 1980 y 1990, los lenguajes imperativos notables que se basaban en conceptos orientados a objetos eran Perl , lanzado por Larry Wall en 1987; Python , lanzado por Guido van Rossum en 1990; Visual Basic y Visual C++ (que incluía Microsoft Foundation Class Library (MFC) 2.0), lanzados por Microsoft en 1991 y 1993 respectivamente; PHP , lanzado por Rasmus Lerdorf en 1994; Java , de James Gosling ( Sun Microsystems ) en 1995, JavaScript , de Brendan Eich ( Netscape ) y Ruby , de Yukihiro "Matz" Matsumoto, ambos lanzados en 1995. .NET Framework de Microsoft (2002) es imperativo en esencia, ya que son sus principales lenguajes de destino, VB.NET y C# que se ejecutan en él; sin embargo, F# de Microsoft , un lenguaje funcional, también se ejecuta en él.
FORTRAN (1958) fue presentado como "El sistema de traducción de fórmulas matemáticas de IBM". Fue diseñado para cálculos científicos, sin instalaciones de manipulación de hilos . Junto con declaraciones , expresiones y declaraciones , admitía:
Tuvo éxito porque:
Sin embargo, proveedores que no son de IBM también escribieron compiladores de Fortran, pero con una sintaxis que probablemente fallaría en el compilador de IBM. [4] El Instituto Nacional Estadounidense de Estándares (ANSI) desarrolló el primer estándar Fortran en 1966. En 1978, Fortran 77 se convirtió en el estándar hasta 1991. Fortran 90 admite:
COBOL (1959) significa "Lenguaje común orientado a los negocios". Símbolos manipulados por Fortran. Pronto se dio cuenta de que los símbolos no tenían por qué ser números, por lo que se introdujeron cadenas. [5] El Departamento de Defensa de EE. UU. influyó en el desarrollo de COBOL, siendo Grace Hopper una de las principales contribuyentes. Las declaraciones eran parecidas al inglés y detalladas. El objetivo era diseñar un lenguaje para que los directivos pudieran leer los programas. Sin embargo, la falta de declaraciones estructuradas obstaculizó este objetivo. [6]
El desarrollo de COBOL estuvo estrictamente controlado, por lo que no surgieron dialectos que requirieran estándares ANSI. Como consecuencia, no se modificó durante 15 años, hasta 1974. La versión de la década de 1990 sí realizó cambios importantes, como la programación orientada a objetos . [6]
ALGOL (1960) significa "Lenguaje ALGOrítmico". Tuvo una profunda influencia en el diseño del lenguaje de programación. [7] Surgió de un comité de expertos en lenguajes de programación europeos y estadounidenses, utilizaba notación matemática estándar y tenía un diseño estructurado legible. Algol fue el primero en definir su sintaxis utilizando la forma Backus-Naur . [7] Esto llevó a compiladores dirigidos por sintaxis . Agregó características como:
Los descendientes directos de Algol incluyen a Pascal , Modula-2 , Ada , Delphi y Oberon en una rama. En otra rama están C , C++ y Java . [7]
BASIC (1964) significa "Código de instrucción simbólico multiusos para principiantes". Fue desarrollado en Dartmouth College para que todos sus estudiantes aprendieran. [8] Si un estudiante no pasara a un idioma más potente, aún recordaría el Básico. [8] Se instaló un intérprete básico 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. [8]
Basic fue pionero en la sesión interactiva . [8] Ofrecía comandos del sistema operativo dentro de su entorno:
Sin embargo, la sintaxis básica era demasiado simple para programas grandes. [8] Los dialectos recientes agregaron estructura y extensiones orientadas a objetos. Visual Basic de Microsoft todavía se utiliza ampliamente y produce una interfaz gráfica de usuario . [9]
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 . [10] 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. [10] Su crecimiento también se debió a que tiene las facilidades del lenguaje ensamblador , pero utiliza una sintaxis de alto nivel . Agregó funciones avanzadas como:
C permite al programador controlar en qué región de la memoria se almacenarán los datos. Las variables globales y las variables estáticas requieren la menor cantidad de ciclos de reloj para almacenarse. 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 de la malloc()función.
main()función. [12] Las variables globales son visibles para main()todas las demás funciones del código fuente.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 de las definiciones de funciones. [13] Proporcionan una interfaz para la función.staticprefijo también se almacenan en la región de datos globales y estáticos . [11] 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ónint increment_counter(){ static int counter = 0; counter++; return counter;}staticprefijo, incluidas las variables de parámetros formales, [15] se denominan variables automáticas [12] y se almacenan en la pila. [11] Son visibles dentro de la función o bloque y pierden su alcance al salir de la función o bloque.malloc()función de biblioteca para asignar memoria de montón. [17] Llenar el montón con datos es una función de copia adicional. Las variables almacenadas en el montón se pasan económicamente a 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 lingüístico para dividir grandes proyectos en módulos . [18] Una característica obvia era descomponer físicamente proyectos grandes en archivos separados . Una característica menos obvia era descomponer lógicamente proyectos grandes en tipos de datos abstractos . [18] 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. [19] Los tipos de datos abstractos son estructuras de tipos de datos concretos, con un nuevo nombre asignado. Por ejemplo, se podría llamar una lista de números enteros .integer_list
En la jerga orientada a objetos, los tipos de datos abstractos se denominan clases . Sin embargo, una clase es sólo una definición; no se asigna memoria. Cuando se asigna memoria a una clase, se le llama objeto . [20]
Lenguajes imperativos orientados a objetos desarrollados combinando la necesidad de clases y la necesidad de una programación funcional segura . [21] Una función, en un lenguaje orientado a objetos, se asigna a una clase. Una función asignada se denomina entonces método , función miembro u operación . La programación orientada a objetos consiste en ejecutar operaciones sobre objetos . [22]
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 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 relaciones de subconjunto/superconjunto mediante herencia . [23] La programación orientada a objetos se convirtió en el paradigma del lenguaje dominante a finales de los años 1990. [18]
C++ (1985) originalmente se llamaba "C con clases". [24] Fue diseñado para ampliar las capacidades de C agregando las funciones orientadas a objetos del lenguaje Simula . [25]
Un módulo orientado a objetos se compone de dos archivos. El archivo de definiciones se llama archivo de encabezado . Aquí hay un archivo de encabezado C++ para la clase GRADE en una aplicación escolar simple:
// grado.h // -------// Se utiliza para permitir que varios archivos fuente incluyan // este archivo de encabezado sin errores de duplicación. // Ver: https://en.wikipedia.org/wiki/Imperative_programming/Include_guard // ------------------------------- --------------- #ifndef GRADE_H #define GRADE_Hclass GRADE { public : // Esta es la operación del constructor. // ---------------------------------- CALIFICACIÓN ( letra de carácter constante ); // Esta es una variable de clase. // ------------------------- letra de carácter ; // Esta es una operación de miembro. // --------------------------- int grade_numeric ( letra de carácter constante ); // Esta es una variable de clase. // ------------------------- int numérico ; }; #terminara si Una operación de constructor es una función con el mismo nombre que el nombre de la clase. [26] Se ejecuta cuando la operación que llama ejecuta la newdeclaración.
El otro archivo de un módulo es el archivo fuente . Aquí hay un archivo fuente C++ para la clase GRADE en una aplicación escolar simple:
// grado.cpp // --------- #incluye "grado.h" GRADE :: GRADE ( const char letter ) { // Hace referencia al objeto usando la palabra clave 'this'. // ---------------------------------------------- este - > letra = letra ; // Esto es Cohesión Temporal // ------------------------- esto -> numérico = grado_numérico ( letra ); } int GRADE :: grade_numeric ( const char letra ) { if ( ( letra == 'A' || letra == 'a' ) ) return 4 ; de lo contrario si ( ( letra == 'B' || letra == 'b' ) ) devuelve 3 ; else if ( ( letra == 'C' || letra == 'c' ) ) devuelve 2 ; else if ( ( letra == 'D' || letra == 'd' ) ) devuelve 1 ; de lo contrario si ( ( letra == 'F' || letra == 'f' ) ) devuelve 0 ; de lo contrario , devuelve -1 ; } Aquí hay un archivo de encabezado C++ para la clase PERSONA en una aplicación escolar simple:
// persona.h // -------- #ifndef PERSON_H #define PERSON_Hclase PERSONA { público : PERSONA ( const char * nombre ); carácter constante * nombre ; }; #terminara si Aquí hay un archivo fuente C++ para la clase PERSONA en una aplicación escolar simple:
// persona.cpp // ---------- #incluye "persona.h" PERSONA :: PERSONA ( const char * nombre ) { este -> nombre = nombre ; } Aquí hay un archivo de encabezado C++ para la clase ESTUDIANTE en una aplicación escolar simple:
// estudiante.h // --------- #ifndef ESTUDIANTE_H #define ESTUDIANTE_H#incluye "persona.h" #incluye "grado.h" // UN ESTUDIANTE es un subconjunto de PERSONA. // -------------------------------- clase ESTUDIANTE : PERSONA pública { público : ESTUDIANTE ( const char * nombre ); ~ ESTUDIANTE (); CALIFICACIÓN * calificación ; }; #terminara si Aquí hay un archivo fuente C++ para la clase ESTUDIANTE en una aplicación escolar simple:
// estudiante.cpp // ----------- #incluye "estudiante.h" #incluye "persona.h" ESTUDIANTE :: ESTUDIANTE ( const char * nombre ) : // Ejecuta el constructor de la superclase PERSONA. // ------------------------------------------------ - PERSONA ( nombre ) { // Nada más que hacer. // ------------------- } ESTUDIANTE ::~ ESTUDIANTE () { // desasignar la memoria de calificaciones // para evitar pérdidas de memoria. // ------------------------------------------------ - eliminar esto -> calificación ; } Aquí hay un programa de controlador para demostración:
// estudiante_dvr.cpp // --------------- #include <iostream> #incluye "estudiante.h" int main ( void ) { ESTUDIANTE * estudiante = nuevo ESTUDIANTE ( "El Estudiante" ); estudiante -> calificación = nueva CALIFICACIÓN ( 'a' ); std :: cout // Aviso que el estudiante hereda el nombre de la PERSONA << estudiante -> nombre << ": Calificación numérica = " << estudiante -> calificación -> numérico << " \n " ; // desasignar la memoria del estudiante // para evitar pérdidas de memoria. // ------------------------------------------------ - eliminar estudiante ; devolver 0 ; } Aquí hay un archivo MAKE para compilar todo:
# makefile # -------- todo : estudiante_dvr limpio : rm estudiante_dvr *.oestudiante_dvr : estudiante_dvr . grado cpp . Oh estudiante . Oh persona . o c++ estudiante_dvr.cpp grado.o estudiante.o persona.o -o estudiante_dvr grado.o : grado . grado cpp . h c++ -c grado.cpp estudiante.o : estudiante . estudiante del cpp . h c++ -c estudiante.cpp persona.o : persona . persona cpp . h c++ -c persona.cpp