Codigo c/C++ ¿Qué es c/c++? C es un lenguaje de programación creado en 1972 por



Descargar 61.87 Kb.
Fecha de conversión09.03.2017
Tamaño61.87 Kb.

CODIGO C/C++

1.¿Qué es c/c++?


C es un lenguaje de programación creado en 1972 por Dennis M. Ritchie en los Laboratorios Bell como evolución del anterior lenguaje B, a su vez basado en BCPL.

Al igual que B, es un lenguaje orientado a la implementación de Sistemas Operativos, concretamente Unix. C es apreciado por la eficiencia del código que produce y es el lenguaje de programación más popular para crear software de sistemas, aunque también se utiliza para crear aplicaciones.

Se trata de un lenguaje débilmente tipificado de medio nivel pero con muchas características de bajo nivel. Dispone de las estructuras típicas de los lenguajes de alto nivel pero, a su vez, dispone de construcciones del lenguaje que permiten un control a muy bajo nivel. Los compiladores suelen ofrecer extensiones al lenguaje que posibilitan mezclar código en ensamblador con código C o acceder directamente a memoria o dispositivos periféricos.

La primera estandarización del lenguaje C fue en ANSI, con el estándar X3.159-1989. El lenguaje que define este estándar fue conocido vulgarmente como ANSI C. Posteriormente, en 1990, fue ratificado como estándar ISO (ISO/IEC 9899:1990). La adopción de este estándar es muy amplia por lo que, si los programas creados lo siguen, el código es portátil entre plataformas y/o arquitecturas.



C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que permitan 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.

Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los fabricantes de compiladores más modernos. Existen también algunos intérpretes, tales como ROOT.

Una particularidad del C++ es la posibilidad de redefinir los operadores (sobrecarga de operadores), y de poder crear nuevos tipos que se comporten como tipos fundamentales.

El nombre C++ fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C.

2.Lo primero que debemos saber en c/c++

2.1¿En qué y donde programaremos?


Pues bien en la web existen varios programas (Compiladores) y también existen editores, Los compiladores nos sirven para editar el código, escribir el código, compilar el código, corregir el código y ejecutarlo y los editores no lo permiten a continuación pondré 4 de los compiladores mas utilizados en la programación de c/c++.

Turbo C

Borland C++

DevC/C++

Geany

Proseguimos a instalar el compilador de preferencia y ahora sí! A programar…


2.2 ¿Qué estudiar y por dónde empezar?


Pues comenzaremos por lo esencial las librerías ejm: include

2.3Librerías: generalidades


Nota:  tenga en cuenta que este capítulo no trata de características que puedan considerarse estándar del lenguaje C++, sino de peculiaridades (aunque muy extendidas) de la construcción de aplicaciones.  Tenga en cuenta también que en informática, el concepto "Librería" es muy general, y no está asociado a ningún lenguaje concreto (aunque C y C++ las utilizan ampliamente). De hecho, es posible y frecuente, utilizar en un lenguaje librerías que han sido escritas en otro. Por ejemplo, buena parte de las librerías de C++Builder, la denominadas VCL "Visual Component Library", han sido desarrolladas en Pascal

2.3.1  Sinopsis


Al tratar de la construcción de un programa señalamos que en ocasiones no se desea construir un ejecutable, al menos no en el sentido tradicional del término, sino una librería, y que estas librerías son trozos de código que contienen alguna funcionalidad pre-construida que puede ser utilizada por un ejecutable. Por supuesto, las librerías contienen en su interior variables y funciones. Si como suponemos son librerías C++, lo más probable es que estas variables y funciones estén encapsuladas en forma de clases Observe que la idea central de librería es precisamente la de ser un módulo de software preconstruido -generalmente por terderos- para cuya utilización no es necesario conocer los detalles íntimos de su funcionamiento, sino su interfaz. Es decir, que respuestas nos puede dar y cómo hay que preguntar -a la librería- para obtenerlas.

En general, el término librería se utiliza para referirse a un conjunto de módulos objeto .obj / .o (resultados de compilación) agrupados en un solo fichero que suele tener las extensiones .lib, .bpl .a, .dll, etc. Estos ficheros permiten tratar las colecciones de módulos como una sola unidad, y representan una forma muy conveniente para el manejo y desarrollo de aplicaciones grandes, además de ser un concepto muy fértil para la industria del software, ya que permiten la existencia de las librerías de los propios compiladores y de un mercado de utilidades y componentes adicionales. Son las denominadas librerías 3pp (de terceras partes), en referencia a que no son incluidas de forma estándar con los compiladores ni creadas por el programador de la aplicación.

En este sentido el software se parece a cualquier otro mercado de componentes. Además de las librerías más o menos extensas que acompañan a los compiladores, pueden adquirirse otras, que permiten añadir a nuestros programas las funcionalidades más diversas sin necesidad de ser un experto en cada área de la programación y sin necesidad de que tengamos que estar reinventando la rueda constantemente.  Si quiere una opinión autorizada -en inglés- sobre la filosofía de uso e importancia de las librerías en C++, puede consultar este documento del Sr. Stroustrup:  Abstraction, libraries, and efficiency in C++

2.3.2Tipos


En lo que respecta al lenguaje C++, existen dos tipos fundamentales de librerías: estáticas y dinámicas, que aunque comparten el mismo nombre genérico "librería", utilizan mecanismos distintos para proporcionar su funcionalidad al ejecutable.

En ambos casos es costumbre, que junto a las librerías propiamente dichas (ficheros .lib, .a, .dll etc), se incluya un fichero .h denominado "de cabecera" porque es tradición utilizar las primeras líneas del programa para poner las directivas #include que los incluirán en el fuente durante la fase de preproceso Este fichero contiene las declaraciones de las entidades contenidas en la librería, así como las macros y constantes predefinidas utilizadas en ella, de forma que el programador solo tiene que incluir el correspondiente fichero .h en su aplicación para poder utilizar los recursos de la librería en cuestión (recuerde que en C/C++ es imprescindible incluir la declaración de cualquier función o clase antes de su utilización Este sistema tiene la ventaja adicional de que proporciona al usuario la información mínima para su uso.  Es decir, la "interfaz" de las funciones o clases que utilizará.  En el caso de funciones esto se concreta en el prototipo en el caso de clases, en la especificación de sus métodos y propiedades públicas.


2.3.3  Librerías estáticas


Denominadas también librerías-objeto, son colecciones de ficheros objeto (compilados) agrupados en un solo fichero de extensión .lib, .a, etc. junto con uno o varios ficheros de cabecera (generalmente .h).

Nota: una posición extrema la constituyen aquellas librerías en las que toda la funcionalidad se ha incluido en el fichero de cabecera .h, en cuyo caso no existen los módulos compilados .lib, .a, etc. Es el caso de la Librería Estándar de Plantillas STL que está compuesta casi exclusivamente por ficheros de cabecera.  No obstante, lo anterior representa un caso extremo que suele ser evitado, ya que por lo general, los autores incluyen en los ficheros de cabecera la información mínima indispensable para utilizar la librería (la interfaz), incluyendo la operatoria en forma de ficheros compilados.  La razón no suele ser otra que proteger la propiedad intelectual (el "know how").

Durante la construcción de la aplicación, el preprocesador incluye en los fuentes los ficheros de cabecera. Posteriormente, durante la fase de enlazado, el linker incluye en el ejecutable los módulos correspondientes a las funciones y clases de librería que hayan sido utilizadas en el programa, de forma que el conjunto entra a formar parte del ejecutable. De ahí su nombre: Librerías enlazadas estáticamente [1].



Dejando aparte consideraciones de comodidad y rapidez, el  resultado de utilizar una de tales librerías no se diferencia en nada al que puede obtenerse escribiendo en al fuente las funciones o clases correspondientes y compilándolas como un módulo más de nuestra aplicación.

Nota:  genralmente los compiladores disponen de herramientas específicas para la creación de librerías estáticas. Por ejemplo, la del compilador Borland C++ es el ejecutable TLIB.EXE las de GNU se denominan ar y ranlib. Como tendremos ocasión de ver en los ejemplos, también pueden crearse mediante opciones específicas en la orden de compilación.

2.3.4  Diccionario


Junto con los módulos .obj que las componen, las librerías estáticas incluyen una especie de índice o diccionario con información sobre su contenido. Este índice contiene los nombres de los recursos públicos de los distintos módulos (que pueden ser accedidos desde el exterior) y su dirección. Estos nombres deben ser distintos para evitar ambigüedades durante el enlazado, y sirven para incrementar la velocidad de enlazado cuando el "Linker" debe incluir alguno en un ejecutable.

Nota:  cuando se crea una librería estática a partir de uno o varios ficheros relocalizables (objetos), el proceso de incluir esta tabla o diccionario de símbolos puede ejecutarse en un solo paso o en dos, aunque siempre en el momento de crear la librería.  Por ejemplo, tlib de Boland crea la librería y la tabla en un solo proceso.  En cambio, ar de GNU puede crear la librería y posteriormente añadir la tabla (esto último puede también hacerse con ranlib).  Cuando se añade un nuevo módulo a una librería existente, la misma herramienta que añade el contenido, se encarga de actualizar el índice. 

2.3.5  Librerías dinámicas


Otra forma de añadir funcionalidad a un ejecutable son las denominadas librerías de enlazado dinámico (repasar en el significado de "enlazado dinámico"), generalmente conocidas como DLLs, acrónimo de su nombre en inglés ("Dynamic Linked Library"). Estas librerías se utilizan mucho en la programación para el SO Windows. Este Sistema contiene un gran número de tales librerías de terminación .DLL, aunque en realidad pueden tener cualquier otra terminación .EXE, .FON, .BPI, .DRV etc. Cualquiera que sea su terminación, de forma genérica nos referiremos a ellas como DLLs, nombre por el que son más conocidas.

Nota:  la programación tradicional de aplicaciones Windows utilizando la API del Sistema es en realidad una sucesión de invocación a funciones contenidas en librerías de este tipo.  En realidad este Sistema Operativo está constituido por un conjunto de DLLs; la mayoría de los ficheros de disco asociados con el Sistema son de este tipo, y se ha llegado a afirmar que escribir una DLL es escribir una extensión del propio Windows (http://www.zator.com/cpp/images/icon_liba.gif PW2E Petzold p.878).

2.3.6Diferencias:  librería Estática "versus" Dinámica


Las diferencias más relevantes de las librerías dinámicas respecto a las estáticas son fundamentalmente dos:

  • Las librerías estáticas quedan incluidas en el ejecutable, mientras las dinámicas son ficheros externos, con lo que el tamaño de la aplicación (nuestro ejecutable) es mayor en el primer caso que en el segundo. Esto puede ser de capital importancia en aplicaciones muy grandes, ya que el ejecutable debe ser cargado en memoria de una sola vez

  • Las librerías dinámicas son ficheros independientes que pueden ser invocados desde cualquier ejecutable, de modo que su funcionalidad puede ser compartida por varios ejecutables. Esto significa que solo se necesita una copia de cada fichero de librería (DLL) en el Sistema. Esta característica constituye la razón principal de su utilización, y es también origen de algunos inconvenientes, principalmente en sistemas como Windows en los que existen centenares de ellas.

Como consecuencia de las diferencias citadas se derivan otras. Por ejemplo:



  • Si se realizan modificaciones en los módulos de una librería estática, es necesario recompilar todos los ejecutables que la utilizan, mientras que esto no es necesario en el caso de una librería dinámica, siempre que su interfaz se mantenga.

  • Como consecuencia de lo anterior, generalmente es más difícil la depuración y mantenimiento de aplicaciones que utilizan librerías dinámicas que las estáticas, ya que en el primer caso, es necesario controlar qué versiones de los ejecutables (.EXE) son compatibles con qué versiones de las DLLs y de estas entre sí, de forma que el usuario no utilice un versiones incompatibles de los ficheros que componen la aplicación.

  • Durante la ejecución de un ejecutable, las librerías estáticas que hubiesen intervenido en su construcción no necesitan estar presentes, en cambio las dinámicas deben estar en el mismo directorio o en el camino de búsqueda "Path"

  • Las librerías estáticas solo se utilizan en la fase de construcción del ejecutable. Las dinámicas se utilizan durante la ejecución.

  • Los ejecutables que utilizan librería estáticas solo incorporan los módulos de aquellas que necesitan para resolver sus símbolos externos.  Por contra, las librerías dinámicas deben ser cargadas en su totalidad aunque no solo se utilice una parte de su funcionalidad (no son divisibles).

  • Las librerías estáticas, que entran a formar parte indivisible del ejecutable, son cargadas con el proceso de carga de este.  Las librerías dinámicas no necesariamente tienen que cargarse con la carga inicial (aunque pueden serlo). De hecho, una librería dinámica puede ser cargada bajo demanda en el momento en que se necesita su funcionalidad, e incluso puede ser descargada cuando no resulta necesaria.

  • El mecanismo de enlazado estático depende del compilador.  El de enlazado dinámico depende del SO, de forma que manteniendo ciertas precauciones, las DLLs construidas con un lenguaje y un compilador pueden ser utilizadas por cualquier aplicación.

2.3.7  Utilizar Librerías


Desde la óptica del programador C++, el manejo de librerías comprende dos aspectos totalmente diferenciados: su utilización y quizás la construcción de alguna de ellas si nuestras aplicaciones son medianamente grandes.

En cuanto al primer punto, es seguro que cualquier aplicación por pequeña que sea, utilice algunas de la Librería Estándar Por ejemplo, cada vez que en su código aparece una sentencia del tipo

cout << "Hola mundo" << endl;

está utilizando una librería estática, y cada vez que en la programación de una aplicación Windows utiliza un mensaje del tipo

MessageBox(NULL, "Hola mundo!", "Mi primer programa", MB_OK);

está usando una librería dinámica.  En cuanto a su construcción, si se dedica a esto de programar en C++, antes o después pondrá manos a la obra. Por cierto: existen empresas de software cuya principal actividad es precisamente fabricar y vender librerías (ya hemos indicado que el mercado de las 3pp es todo un "mundillo" dentro de la informática).



Cualquiera que sea el caso, tanto la utilización como la construcción, son diferentes según se trate de librerías estáticas o dinámicas. En las páginas que siguen se describen en detalle ambas situaciones. Empezaremos por una descripción general de su funcionamiento, para continuar con la descripción de los pasos necesarios para construirlas.  A continuación exponemos los detalles de su utilización, incluyendo un ejemplo de construcción de un ejecutable que utiliza los recursos de una librería.

3. Conozca algunas Librerías


  • stdio.h

  • ctype.h

  • string.h

  • math.h

  • stdlib.h

  • assert.h

  • setjmp.h

  • signal.h

  • time.h

Input and Output:

  • FILE *fopen(const char *filename, const char *mode)

  • FILE *freopen(const char *filename, const char *mode, FILE *stream)

  • int fflush(FILE *stream)

  • int fclose(FILE *stream)

  • int remove(const char *filename)

  • int rename(const char *oldname, const char *newname)

  • FILE *tmpfile(void)

  • char *tmpnam(char s[L_tmpnam])

  • int setvbuf(FILE *stream, char *buf, int mode, size_t size)

  • void setbuf(FILE *stream, char *buf)

  • int fprint(FILE *stream, const char *format, …)

  • int sprintf(char *s, const char *format, …)

  • vprintf(const char *format, va_list arg)

  • vfprintf(FILE *stream, const char *format, va_list arg)

  • vsprintf(char *s, const char *format, va_list arg)

  • int fscanf(FILE *stream, const char *format, …)

  • int scanf(const char *format, …)

  • int sscanf(char *s, const char *format, …)

  • int fgetc(FILE *stream)

  • char *fgets(char *s, int n, FILE *stream)

  • int fputc(int c, FILE *stream)

  • int fputs(const char *s, FILE *stream)

  • int getc(FILE *stream)

  • int getchar(void)

  • char *gets(char *s)

  • int putc(int c, FILE *stream)

  • int putchar(int c)

  • int ungetc(int c, FILE *stream)

  • size_t fread(void *ptr, size_t size, size_t nobj, FILE *stream)

  • size_t fwrite(const void *ptr, size_t size, size_t nobj, FILE *stream)

  • int fseek(FILE *stream, long offset, int orogin)

  • long ftell(FILE *stream)

  • void rewind(FILE *stream)

  • int fgetpos(FILE *stream, fpos_t *ptr)

  • int fsetpos(FILE *stream, const fpos_t *ptr)

  • void clearerr(FILE *stream)

  • int feof(FILE *stream)

  • int ferror(FILE *stream)

  • void perror(const char *s)

Character Class Tests:

  • isalnum(c)

  • isalpha(c)

  • iscntrl(c)

  • isdigit(c)

  • isgraph(c)

  • islower(c)

  • isprint(c)

  • ispunct(c)

  • isspace(c)

  • isupper(c)

  • isxdigit(c)

String Functions:

  • char *strcpy(s , ct)

  • char *strncpy(s , ct , n)

  • char *strcat(s , ct)

  • char *strncat(s , ct , n)

  • int strcmp(cs , ct)

  • int strncmp(cs , ct ,n)

  • char *strchr(cs , c)

  • char *strrchr(cs , c)

  • size_t strspn(cs , ct)

  • size_t strcspn(cs , ct)

  • char *strstr(cs , ct)

  • size_t strlen(cs)

  • char *strerror(n)

  • char *strtok(s , ct)

Mathematical Functions:

  • sin(x)

  • cos(x)

  • tan(x)

  • asin(x)

  • acos(x)

  • atan(x)

  • atan2(x)

  • sinh(x)

  • cosh(x)

  • tanh(x)

  • exp(x)

  • log(x)

  • log10(x)

  • pow(x,y)

  • sqrt(x)

  • ceil(x)

  • floor(x)

  • fabs(x)

  • ldexp(x)

  • frexp(x,double *ip)

  • modf(x,double *ip)

  • fmod(x,y)

Utility Functions:

  • double atof(const char *s)

  • int atoi(const char *s

  • long atol(const char *s)

  • double strrod(const char *s, char **endp)

  • long strtol(const char *s, char **endp, int base)

  • unsigned long strtoul(const char *s, char **endp, int base)

  • int rand(void)

  • void srand(unsigned int seed)

  • void *calloc(size_t nobj, size_t size)

  • void *malloc(size_t size)

  • void *realloc(void *p, size_t size)

  • void free(void *p)

  • void abort(void)

  • void exit(int status)

  • int atexit(void (*fcn)(void))

  • int system(const char *s)

  • char *getenv(const char *name)

  • void *bsearch(const void *key, const void *base, size_t n, size_t size, int (*cmp)(const void *keyval, const void *datum))

  • void qsort(void *base, size_t n, size_t size, int (*cmp)(const void *, const void *))

  • int abs(int n)

  • long labs(long n)

  • div_t div(int num, int denom)

  • ldiv_t ldiv(long num , long denom)

Diagnostics:

  • void assert(int expression)

Non-local Jumps:

  • int setjmp(jmp_buf env)

  • void longjmp(jmp_buf env, int val)

Signals:

  • void (*signal(int sig, void (*handler)(int)))(int)

Data and Time Functions:

  • clock_t clock(void)

  • time_t time(time_t , *tp)

  • double difftime(time_t time2 , time_t time1)

  • time_t mktime(struct tm *tp)

  • char *asctime(const time_t *tp)

  • char *ctime(const time_t *tp)

  • struct tm *gmtime(const time_t *tp)

  • struct tm *localtime(const time_t *tp)

  • size_t strftime(char *s, size_t smax, const char *fmt, const struct tm *tp)


3.1 Bibliografia


http://www.fepe55.com.ar/blog/2007/07/02/todas-las-librerias-y-funciones-standard-del-lenguaje-c/#stdio

http://www.zator.com/Cpp/E5.htm



http://es.wikipedia.org/wiki


Geo560176


La base de datos está protegida por derechos de autor ©bazica.org 2016
enviar mensaje

    Página principal