Manual de usuario (C/C++)

Manual de c/C++Facilitador: Ing. Elsner B. González O.

DESCRIPCIÓN BREVEManual de usuario de los lenguajes de programación C y C++.

Joshtin Antonio Meléndez OcampoLaboratorio de Programación I

Introducción

Este es un manual de usuario de los lenguajes de programación en C y C++ el cual presenta la mayoría de las características que tienen que saberse al usar estos lenguajes, desde la declaración

de una variable, palabras reservadas, arreglos, etc.

El manual fue creado con el propósito de afinar y reforzar los saberes de los programadores con falta de experiencia, conocimientos y practica endicha materia.

1

Índice

ContenidoIntroducción.......................................................................................................................................1

Índice..................................................................................................................................................2

Identificador.......................................................................................................................................4

Tipos de datos....................................................................................................................................5

Declaración de Variables en lenguaje C.............................................................................................5

Declaración de Variables en Lenguaje C++.........................................................................................7

Asignar un valor a una variable en C..................................................................................................8

Asignar un valor a una variable en C++..............................................................................................9

Palabras reservadas en C y C ++.......................................................................................................10

Palabras que no provienen de C y que, por tanto, solo utiliza C++:.................................................11

Comandos de salida de C.................................................................................................................12

Comandos de salida de C++.............................................................................................................13

Operadores......................................................................................................................................15

Operadores Aritméticos...............................................................................................................16

Operadores Relacionales..............................................................................................................16

Operadores Logicos......................................................................................................................16

Operadores de Asignacion...........................................................................................................16

Tabla ASCII.......................................................................................................................................17

Operador (Función) SizeOf...............................................................................................................18

Arreglos............................................................................................................................................19

Arreglos Unidimensionales:..........................................................................................................19

Arreglos Bidimensionales.............................................................................................................20

Arreglos de estructuras....................................................................................................................21

printf y scanf....................................................................................................................................22

Ficheros............................................................................................................................................23

Función fopen..................................................................................................................................24

Función fclose..................................................................................................................................25

Función fputs...................................................................................................................................26

Función feof.....................................................................................................................................27

Función fgets....................................................................................................................................28

2

Función fputs...................................................................................................................................29

Función fread...................................................................................................................................30

Función fwrite..................................................................................................................................31

Funciones.........................................................................................................................................32

Funciones tipo Void..........................................................................................................................33

Anexos..............................................................................................................................................34

Ejercicio violento - Ejemplo..............................................................................................................35

Login – Ejemplo................................................................................................................................40

Empleado – Ejemplo........................................................................................................................44

Farmacord (Proyecto de C/C++).......................................................................................................54

3

Identificador

Un identificador es una secuencia de caracteres alfabéticos, numéricos y el guion bajo. Con ellos podemos dar nombres a variables, constantes, tipos de datos, nombres de funciones o procedimientos, etc.

Cada lenguaje de programación tiene sus propias características del tamaño del identificador; el estándar de lenguaje C no especifica límite de tamaño para un identificador, pero para ciertas implementaciones de C++ solo los primeros 31 caracteres son significativos.

Reglas para el nombramiento de un identificador:

I. Debe comenzar con una letra (A a Z) mayúscula o minúscula y no puede contener espacios en blanco.

II. En lenguaje C, el carácter “_” (Guion bajo) es considerado como letra, por lo que puede ser utilizado como primer carácter.

III. Letras, dígitos, y el carácter guion bajo están permitidos después del primer carácter.

IV. No pueden existir dos identificadores iguales, es decir, dos elementos de un programa no pueden nombrarse de la misma forma. Sim embargo, un identificador puede aparecer mas de una vez en un programa.

V. No se puede utilizar una palabra reservada como identificador, sin embargo, los identificadores estándar se pueden definir.

VI. En lenguaje C existen identificadores que podrían tener uno o varios puntos, tales como: persona.apellidoPaterno

4

Tipos de datos

Los diferentes objetos de información con los que un algoritmo o programa trabaja se conocen colectivamente como datos.

Todos los datos tienen un tipo asociado con ellos; el tipo de un dato es el conjunto de valores que puede tomar durante el programa.

Cabe destacar que el tipo de dato a digitalizar debe ser correctamente usado, por ejemplo, para un entero ( 24 ) se debe usar el tipo de dato “int”, de lo contrario si se usara un tipo de dato como “float”, no se podrá hacer ningún tipo de operación con ese dato.

Ejemplo:

5

Declaración de Variables en lenguaje CEn lenguaje C la sintaxis para declarar una variable es la siguiente:

Tipo_de_dato _ Nombre_variable

tipo_de_dato_ es cualquier tipo válido de C; estos pueden ser enteros, flotantes, cadenas…

nombre_variable es un identificador válido en C, esto es, una letra seguida opcionalmente por otras letras y números.

Téngase en cuenta que no se admiten signos diacríticos (acentos, tildes, etc.) y que las letras mayúsculas y minúsculas no se consideran equivalentes. Por otra parte, no se admite utilizar como identificadores los nombres de palabras reservadas en C.

Ejemplo:

6

Declaración de Variables en Lenguaje C++El sistema es siempre el mismo, primero se especifica el tipo y a continuación una lista de variables y finalmente un punto y coma.

La declaración de variables es uno de los tipos de sentencia de C++.

La prueba más clara de esto es que la declaración terminará con un ";".

<tipo> <lista de variables>;

Ejemplo:

8

Asignar un valor a una variable en CEn el lenguaje C la asignación es un operador y la operación de asignación puede formar parte de una expresión que sea parte de otra asignación. El valor de una asignación será siempre el de su parte derecha.

Ejemplo:

9

Asignar un valor a una variable en C++

La sintaxis es la misma, cabe destacar que es posible inicializar las variables dentro de la misma declaración.

Ejemplo:

10

Palabras reservadas en C y C ++

Las palabras reservadas son identificadores predefinidos que tienen significados especiales y no pueden usarse como identificadores creados por el usuario en los programas.

Las palabras reservadas de C++ pueden agruparse en 3 grupos.

El primero contiene las palabras de C y que C++ como evolución de C también contiene:

Auto, const, double, float, int, short, struct, unsigned, break, continue, else, for, long, signed, switch, void, case, default, enum, goto, register, sizeof, typedef, volatile, char, do, extern, if, return, static, union, while,

11

Palabras que no provienen de C y que, por tanto, solo utiliza C++:

asm dynamic_cast namespace reinterpret_cast try bool explicit

new static_cast typeid catch false operator template

typename class friend private this using const_cast inline

public throw virtual delete mutable protected true wchar_t

Las siguientes palabras reservadas se han añadido como alternativas para algunos operadores de C++ y hacen los programas más legibles y fáciles de escribir:

and bitand compl not_eq or_eq xor_eq and_eq bitor not or xor

12

Comandos de salida de C

Se refiere a las operaciones que se producen en el teclado y en la pantalla de la computadora. En C no hay palabras claves para realizar las acciones de Entrada/Salida,estas se hacen mediante el uso de las funciones de la biblioteca estándar (stadio.h).Para utilizar las funciones de E / S debemos incluir en el programa el archivo decabecera, ejemplo: stdio.h, mediante la declaratoria:

#include <stdio.h>

Las Funciones de E/S más simples son getchar() que lee un carácter del teclado, esperaun retorno, es decir un

enter

y el eco aparece. Es decir la tecla presionada.

putchar():

Imprime un carácter en la pantalla, en la posición actual del cursor.Algunas variaciones:

getche():

Aparece el Eco

getch():

No aparece el ecoestas instrucciones se encuentran en la biblioteca

conio.h

13

Comandos de salida de C++

Cuando nos referimos a entrada/salida estándar (E/S estándar) queremos decir que los datos o bien se están leyendo del teclado, ó bien se están escribiendo en el monitor de video. Como se utilizan muy frecuentemente se consideran como los dispositivos de E/S por default y no necesitan ser nombrados en las instrucciones de E/S.

En el lenguaje c++ tenemos varias alternativas para ingresar y/o mostrar datos, dependiendo de la librería que vamos a utilizar para desarrollar el programa, entre estas están: iostream.h y sodio.h.

< IOSTREAM.H>

Las operaciones de entrada y salida no forman parte del conjunto de sentencias de C++, sino que pertenecen al conjunto de funciones y clases de la biblioteca estándar de C++. Ellas se incluyen en los archivos de cabecera iostream.h por lo que siempre que queramos utilizarlas deberemos introducir la línea de código #include <iostream.h>

Esta biblioteca es una implementación orientada a objetos y está basada en el concepto de flujos. A nivel abstracto un flujo es un medio de describir la secuencia de datos de una fuente a un destino o sumidero. Así, por ejemplo, cuando se introducen caracteres desde el teclado, se puede pensar en caracteres que fluyen o se trasladan desde el teclado a las estructuras de datos del programa.

Los objetos de flujo que vienen predefinidos serán:

cin, que toma caracteres de la entrada estándar (teclado);

cout, pone caracteres en la salida estándar (pantalla);

cerr y clog ponen mensajes de error en la salida estándar.

Estos objetos se utilizan mediante los operadores << y >>. El operador << se denomina operador de inserción; y apunta al objeto donde tiene que enviar la información. Por lo tanto la sintaxis de cout será:

cout<<variable1<<variable2<<...<<variablen;

No olvidemos que las cadenas de texto son variables y se ponen entre " " (comillas dobles).

Por su parte >> se denomina operador de extracción, lee información del flujo cin (a la izquierda del operador) y las almacena en las variables indicadas a la derecha). La sintaxis sería la siguiente:

cin>>variable1>>...>>variablen;

<STDIO.H>

14

Operaciones de salida.

Printf: Imprimir en pantalla

Para utilizar la función printf en nuestros programas debemos incluir la directiva:

#include <stdio.h>

Si sólo queremos imprimir una cadena basta con escribir la siguiente línea de código.

printf( "Cadena" );

Como resultado muestra en pantalla:

Cadena

Lo que pongamos entre las comillas es lo que vamos a sacar por pantalla.

15

Operadores

Un operador es un símbolo que permite relacionar dos datos en una expresión y evaluar el resultado de la operación.

Los programas de las computadoras se apoyan esencialmente en la realización de numerosas operaciones aritméticas y matemáticas de diferente complejidad.

Los operadores fundamentales son:

Aritméticos

Relacionales

Lógicos

Asignación

16

Operadores Aritméticos

Los operadores aritméticos (+, -, *, /) pueden ser utilizados con tipos enteros o reales y sirven para realizar operaciones aritméticas básicas.

Operadores Relacionales

Describen una relación entre dos valores; por lo tanto, se usan para expresar condiciones y comparar dos valores.

El resultado de una expresión relacional es un valor tipo lógico o booleano, solo puede ser verdadero o falso.

Estos operadores son: (<,>, ==,>=, <= ,!= ).

Operadores Logicos

Las expresiones lógicas pueden combinarse para formar expresiones mas complejas utilizando los operadores lógicos.

Estos operadores son: && ( Y ), || ( o ), ! (no ),.

Operadores de Asignacion

El operador de asignación permite evaluar una expresión y asignar el resultado en una variable como por ejemplo:Ejemplo:

17

Tabla ASCII

18

Operador (Función) SizeOf

El operador sizeof proporciona la cantidad de almacenamiento, en bytes, necesaria para almacenar un objeto del tipo del operando. Este operador permite no tener que especificar tamaños de datos dependientes del equipo en los programas.

Ejemplo:

19

Arreglostipo de dato estructurado que almacena en una sola variable un conjunto limitado de datos o elementos del mismo tipo. Asimismo, es un conjunto de localidades de memoria contiguas donde la dirección más baja corresponde al primer elemento y la dirección más alta al último. Por sí mismo, el nombre del arreglo apunta a la dirección del primer elemento del arreglo.

Un arreglo se caracteriza por:

1. Ser una lista de un número finito de n elementos del mismo tipo.

2. Almacenar los elementos del arreglo en memoria contigua.

3. Tener un único nombre de variable que representa a todos los elementos y éstos se diferencian por un índice o subíndice.

4. Acceder de manera directa o aleatoria a los elementos individuales del arreglo, por el nombre del arreglo y el índice o subíndice.

Conocemos dos tipos de arreglos:

Arreglos Unidimensionales:

Un arreglo unidimensional es un conjunto de n elementos del mismo tipo almacenados en memoria continua en un vector o lista. Para acceder a cada elemento del arreglo se requiere de un solo índice o subíndice, el cual representa la posición en la que se encuentra.Sintaxis:tipo_dato identif_arreglo[tam_arreglo];

tipo_dato se refiere al tipo de dato de cada elemento del arreglo; puede ser entero, real, carácter, etcétera. identif_arreglo es el nombre que representa a todo el arreglo tam_arreglo es la cantidad de elementos que contiene el arreglo.

Ejemplo:

20

Arreglos BidimensionalesUn arreglo bidimensional es un conjunto de n elementos del mismo tipo almacenados en memoria contigua en una matriz o tabla. A diferencia de los arreglos unidimensionales que sólo requieren de un subíndice, los arreglos bidimensionales para acceder a cada elemento del arreglo requieren de dos índices o subíndices declarados en dos pares de corchetes, donde el primer corchete se refiere al tamaño de filas y el segundo al tamaño de columnas.

Sintaxis:

tipo_dato ident_arr [tam_fila][tam_col];

tipo_dato es el tipo de dato de todo el arreglo.

ident_arr es el nombre del arreglo.

tam_fila es el total de filas.

tam_col es el total de columnas.

Ejemplo:

21

Arreglos de estructuras

Una estructura define una plantilla con la que posteriormente se puede declarar una variable. Una de las características de las estructuras es que hay que definirlas antes de usarlas en la declaración de variables. En la definición no se declara ni reservando memoria para ninguna variable, sólo se construye una estructura con determinadas características, para después poder declarar una variable de ese tipo.

22

Para crear una estructura primero comenzamos por definir el tipo de estructura, para ello se procede de manera parecida a la definición de una variable, con algunas modificaciones; en lenguaje C para definir una estructura, se utiliza la palabra reservada struct, normalmente seguida por un nombre y llave izquierda; después se define el tipo y nombre para uno o más campos.

Ejemplo:

23

printf y scanfLa función scanf() se usa para la entrada y nos permite leer (introducir) datos desde el teclado y asignarlos a variables de C, de acuerdo con el formato especificado. Sintaxis: scanf (“cadena de control”, argumento1, argumento2 …); La cadena de control tiene uno o varios especificadores o códigos de formato que harán referencia al tipo de dato de los argumentos y, si se desea, su anchura.

Ejemplo:

La función printf() es similar a la función scanf(), pero se usa para la salida; permite escribir textos y datos en la pantalla con determinado formato.

Sintaxis:

printf (“cadena de control”, argumento1,argumento2…);

Ejemplo:

24

Ficheros

C define la estructura de datos FILE en el fichero de cabecera stdio.h para el manejo de ficheros.

Nosotros siempre usaremos punteros a estas estructuras.

La definición de ésta estructura depende del compilador, pero en general mantienen un campo con la posición actual de lectura/escritura, un buffer para mejorar las prestaciones de acceso al fichero y algunos campos para uso interno.

25

Función fopenSintaxis:

FILE *fopen(char *nombre, char *modo);

Esta función sirve para abrir y crear ficheros en disco. El valor de retorno es un puntero a una estructura FILE. Los parámetros de entrada son:

nombre: una cadena que contiene un nombre de fichero válido, esto depende del sistema operativo que estemos usando. El nombre puede incluir el camino completo.

modo: especifica el tipo de fichero que se abrirá o se creará y el tipo de datos que puede contener, de texto o binarios:

r: sólo lectura. El fichero debe existir.

w: se abre para escritura, se crea un fichero nuevo o se sobrescribe si ya existe.

a: añadir, se abre para escritura, el cursor se sitúa al final del fichero. Si el fichero no existe, se crea.

r+: lectura y escritura. El fichero debe existir.

w+: lectura y escritura, se crea un fichero nuevo o se sobrescribe si ya existe.

a+: añadir, lectura y escritura, el cursor se sitúa al final del fichero. Si el fichero no existe, se crea.

t: tipo texto, si no se especifica "t" ni "b", se asume por defecto que es "t"

b: tipo binario.

26

Función fclose

Sintaxis:

int fclose(FILE *fichero);

Es importante cerrar los ficheros abiertos antes de abandonar la aplicación. Esta función sirve para eso. Cerrar un fichero almacena los datos que aún están en el buffer de memoria, y actualiza algunos datos de la cabecera del fichero que mantiene el sistema operativo. Además permite que otros programas puedan abrir el fichero para su uso. Muy a menudo, los ficheros no pueden ser compartidos por varios programas.

Un valor de retorno cero indica que el fichero ha sido correctamente cerrado, si ha habido algún error, el valor de retorno es la constante EOF. El parámetro es un puntero a la estructura FILE del fichero que queremos cerrar.

27

Función fputs

Sintaxis:

int fputs (int caracter, FILE *fichero);

Esta función escribe un carácter a un fichero.

El valor de retorno es el carácter escrito, si la operación fue completada con éxito, en caso contrario será EOF. Los parámetros de entrada son el carácter a escribir, convertido a int y un puntero a una estructura FILE del fichero en el que se hará la escritura.

28

Función feof

Sintaxis:

int feof(FILE *fichero);

Esta función sirve para comprobar si se ha alcanzado el final del fichero. Muy frecuentemente deberemos trabajar con todos los valores almacenados en un archivo de forma secuencial, la forma que suelen tener los bucles para leer todos los datos de un archivo es permanecer leyendo mientras no se detecte el fin de fichero. Esta función suele usarse como prueba para verificar si se ha alcanzado o no ese punto.

El valor de retorno es distinto de cero sólo si no se ha alcanzado el fin de fichero. El parámetro es un puntero a la estructura FILE del fichero que queremos verificar.

29

Función fgets

Sintaxis:

char *fgets(char *cadena, int n, FILE *fichero);

Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-1 caracteres o hasta que lea un retorno de línea. En este último caso, el carácter de retorno de línea también es leído.

El parámetro n nos permite limitar la lectura para evitar derbordar el espacio disponible en la cadena.

El valor de retorno es un puntero a la cadena leída, si se leyó con éxito, y es NULL si se detecta el final del fichero o si hay un error. Los parámetros son: la cadena a leer, el número de caracteres máximo a leer y un puntero a una estructura FILE del fichero del que se leerá.

30

Función fputs

Sintaxis:

int fputs(const char *cadena, FILE *stream);

La función fputs escribe una cadena en un fichero. No se añade el carácter de retorno de línea ni el carácter nulo final.

El valor de retorno es un número no negativo o EOF en caso de error. Los parámetros de entrada son la cadena a escribir y un puntero a la estructura FILE del fichero donde se realizará la escritura.

31

Función freadSintaxis:

size_t fread(void *puntero, size_t tamaño, size_t nregistros, FILE *fichero);

Esta función está pensada para trabajar con registros de longitud constante. Es capaz de leer desde un fichero uno o varios registros de la misma longitud y a partir de una dirección de memoria determinada. El usuario es responsable de asegurarse de que hay espacio suficiente para contener la información leída.

El valor de retorno es el número de registros leídos, no el número de bytes. Los parámetros son: un puntero a la zona de memoria donde se almacenarán los datos leídos, el tamaño de cada registro, el número de registros a leer y un puntero a la estructura FILE del fichero del que se hará la lectura.

32

Función fwrite

Sintaxis:

size_t fwrite(void *puntero, size_t tamaño, size_t nregistros, FILE *fichero);

Esta función también está pensada para trabajar con registros de longitud constante y forma pareja con fread. Es capaz de escribir hacia un fichero uno o varios registros de la misma longitud almacenados a partir de una dirección de memoria determinada.

El valor de retorno es el número de registros escritos, no el número de bytes. Los parámetros son: un puntero a la zona de memoria donde se almacenarán los datos leídos, el tamaño de cada registro, el número de registros a leer y un puntero a la estructura FILE del fichero del que se hará la lectura.

33

Funciones

Una función es un conjunto de líneas de código que realizan una tarea específica y puede retornar un valor.

Las funciones pueden tomar parámetros que modifiquen su funcionamiento. Las funciones son utilizadas para descomponer grandes problemas en tareas simples y para implementar operaciones que son comúnmente utilizadas durante un programa y de esta manera reducir la cantidad de código.

Cuando una función es invocada se le pasa el control a la misma, una vez que esta finalizó con su tarea el control es devuelto al punto desde el cual la función fue llamada.

Normalmente, las funciones operan sobre ciertos valores pasados a las mismas ya sea como constantes literales o como variables, aunque se pueden definir funciones que reciban parámetros. Existen dos formas en C++ de pasar parámetros a una función; por referencia o por valor. El hecho es que si en una declaración de función se declaran parámetros por referencia, a los mismos no se les podrá pasar valores literales ya que las referencias apuntan a objetos (variables o funciones) residentes en la memoria; por otro lado, si un parámetro es declarado para ser pasado por valor, el mismo puede pasarse como una constante literal o como una variable. Los parámetros pasados por referencia pueden ser alterados por la función que los reciba, mientras que los parámetros pasados por valor o copia no pueden ser alterados por la función que los recibe, es decir, la función puede manipular a su antojo al parámetro, pero ningún cambio hecho sobre este se reflejará en el parámetro original.

Parámetros por valor

La función cuadrado() (ver arriba) es un clásico ejemplo que muestra el paso de parámetros por valor, en ese sentido la función cuadrado() recibe una copia del parámetro n. En la misma función se puede observar que se realiza un calculo ( n*n ), sin embargo el parámetro original no sufrirá cambio alguno, esto seguirá siendo cierto aún cuando dentro de la función hubiera una instrucción parecida a n = n * n; o n*=n;.

Parámetros por referencia

Para mostrar un ejemplo del paso de parámetros por referencia, vamos a retomar el caso de la función cuadrado, salvo que en esta ocasión cambiaremos ligeramente la sintaxis para definir la misma.

34

Funciones tipo Void

Cuando se utiliza como un tipo de valor devuelto de función, la palabra clave void especifica que la función no devuelve ningún valor. Cuando se utiliza para la lista de parámetros de una función, void especifica que la función no toma ningún parámetro.

Cuando se utiliza en la declaración de un puntero, void especifica que el puntero es "universal".

Si el tipo de puntero es void *, el puntero puede señalar a cualquier variable que no se declare con la palabra clave const ovolatile.

Un puntero void no se puede desreferenciar a menos que se convierta en otro tipo. Un puntero void se puede convertir en cualquier otro tipo de puntero de datos.

Un puntero void puede señalar a una función, pero no a un miembro de clase en C++.

No se puede declarar una variable de tipo void.

Ejemplo de Void:

35

Anexos

36

Ejercicio violento - Ejemplo

37

Login – Ejemplo

42

Empleado – Ejemplo

46

Farmacord (Proyecto de

C/C++)

56

Manual de usuario (C/C++)

Education

Transcript of Manual de usuario (C/C++)