Manual C/C++ Néstor Flores

Manual C/C++

UCA

Facultad de Ciencia, Tecnología y Ambiente

Laboratorio De Programación I

Nombre: Néstor Josué Flores González

Facilitado por: Ing. Elsner B. González O

TABLA DE CONTENIDO

Tabla de contenido...................................................................................................2

Introducción al lenguaje C/C++................................................................................1

Definición y origen de C........................................................................................1

Definición y origen de C++...................................................................................2

Palabras reservadas................................................................................................3

Operadores y Tipos de datos...................................................................................5

Operadores...........................................................................................................5

Aritméticos........................................................................................................5

Incremento y decremento.................................................................................5

Relacionales......................................................................................................6

Lógicos..............................................................................................................7

Operadores de asignación................................................................................7

Operador condicional........................................................................................8

Identificadores......................................................................................................9

Tipos de datos....................................................................................................10

Numéricos.......................................................................................................10

Tipo reales o de coma flotante (float/double):.................................................11

Lógicos (booleanos en C++)...........................................................................11

Caracteres.......................................................................................................11

Void.................................................................................................................11

Juego de caracteres permitidos..........................................................................13

Variables.............................................................................................................14

Cómo declarar una variable............................................................................14

Entrada de datos: Leer datos.................................................................................16

Leer datos en Lenguaje C..................................................................................16

Salida de datos: Imprimir datos..............................................................................18

Función sizeof ().....................................................................................................21

Conversión de datos o Casting..............................................................................22

Arreglos..................................................................................................................25

Arreglo unidimensional.......................................................................................25

Leer un arreglo...................................................................................................27

Imprimir un arreglo..............................................................................................27

Arreglos bidimensionales....................................................................................28

Inicializar un arreglo bidimensional.................................................................29

Estructuras.............................................................................................................34

Ficheros..................................................................................................................43

Archivo de texto..................................................................................................43

Archivo Binario....................................................................................................43

Manejo de archivos.............................................................................................43

Apertura de archivos...........................................................................................43

Modos de apertura..............................................................................................44

Funciones...........................................................................................................44

Función fopen()...............................................................................................44

Función fclose()...............................................................................................45

Función fseek ()..............................................................................................45

ftell ()...............................................................................................................46

Otras funciones...............................................................................................46

Estructuras de control de Datos.............................................................................47

Estructuras Condicionales..................................................................................47

Sentencia If simple..........................................................................................47

Condicional doble (if- else)..............................................................................48

Condiciones anidadas (if-else)........................................................................48

Switch..............................................................................................................50

Estructuras repetitivas........................................................................................50

While...............................................................................................................50

Do-While.........................................................................................................51

For...................................................................................................................51

Programación Modular...........................................................................................52

Función main()....................................................................................................53

Funciones...........................................................................................................53

Ejecución de Funciones..................................................................................53

Llamada o invocación de una función.............................................................53

Prototipo de una función.................................................................................53

Argumentos de Funciones..............................................................................54

Forma de transferir argumentos..................................................................54

INTRODUCCIÓN AL LENGUAJE C/C++Definición y origen de CEl lenguaje C es un lenguaje de programación de propósito general que ofrece a los programadores economía sintáctica, control de flujo y estructuras sencillas y un buen conjunto de operadores.

Se dice que no es un lenguaje de muy alto nivel y más bien un lenguaje pequeño, sencillo ya que no está especializado en ningún tipo de aplicación. Pero a la vez es esto lo hace un lenguaje potente, con un campo de aplicación ilimitado y sobre todo, se aprende rápidamente. En poco tiempo, un programador puede utilizar la totalidad del lenguaje.

Este lenguaje ha sido estrechamente ligado al sistema operativo UNIX, puesto que fueron desarrollados conjuntamente. Sin embargo, este lenguaje no está ligado a ningún sistema operativo ni a ninguna máquina concreta. Se le suele llamar lenguaje de programación de sistemas debido a su utilidad para escribir compiladores y sistemas operativos, aunque de igual forma se puede desarrollar cualquier tipo de aplicación.

La base de C fue escrito por Martin Richards, y del B escrito por Ken Thompson en 1970 para el primer sistema UNIX en un DEC PDP-7. Estos son lenguajes sin tipos, al contrario que el C que proporciona varios tipos de datos. Los tipos que ofrece son caracteres, números enteros y en coma flotante, de varios tamaños. Además se pueden crear tipos derivados mediante la utilización de punteros, vectores, registros y uniones. El primer compilador de C fue escrito por Dennis Ritchie para un DEC PDP-11 y escribió el propio sistema operativo en C.

C trabaja con tipos de datos que son directamente tratables por el hardware de la mayoría de computadoras actuales, como son los caracteres, números y direcciones. Estos tipos de datos pueden ser manipulados por las operaciones aritméticas que proporcionan las computadoras. No proporciona mecanismos para tratar tipos de datos que no sean los básicos, debiendo ser el programador el que los desarrolle. Esto permite que el código generado sea muy eficiente y de ahí el éxito que ha tenido como lenguaje de desarrollo de sistemas. No proporciona otros mecanismos de almacenamiento de datos que no sea el estático y no proporciona mecanismos de entrada ni salida. Ello permite que el lenguaje sea reducido y los

Néstor josue flores 1

compiladores de fácil implementación en distintos sistemas. Por contra, estas carencias se compensan mediante la inclusión de funciones de librería para realizar todas estas tareas, que normalmente dependen del sistema operativo.

Definición y origen de C++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 lenguaje de programación C mecanismos que permiten 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 sumaron a los paradigmas de programación estructurada y 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, 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


https://es.wikipedia.org/wiki/C_(lenguaje_de_programaci%C3%B3n)

PALABRAS RESERVADAS

En C, como en cualquier otro lenguaje, existen una serie de palabras clave (keywords) que no puede utilizarse como identificadores. Estas palabras sirven para indicar al computador que realice una tarea muy determinada (desde evaluar una comparación, hasta definir el tipo de una variable) y tienen un especial significado para el compilador. Las más utilizadas son:

Palabras reservadas de C

Palabra reservada Función

abs () Calcula el valor absoluto

char Tipo de dato carácter

case Si se cumple un caso (condición)

default Opción predeterminada

typedef Crea un nuevo nombre de tipo para uno ya definido

for Estructura de ciclo (Desde/Para)

int Tipo de dato entero

{ Inicio de un programa

} Fin del programa

do Estructura de ciclo

printf Imprime en pantalla

puts Imprime una cadena

scanf Lee una variable

gets Lee una cadena de caracteres

clrscr Borra el contenido de la pantalla

while Estructura de un ciclo

void Valor nulo

main Programa principal

sqrt Calcula raíz cuadrada


struct Estructura

float Tipo de dato real

return Regresa valor a otra función

break Termina el caso

switch Estructura de selectiva

if Estructura de condición (If)

else Estructura de condición (sino)


OPERADORES Y TIPOS DE DATOS

OperadoresUno de los puntos fuertes de C/C++ es su gran variedad de operadores y la flexibilidad que éstos disponen.

Los operadores son símbolos que permiten relacionar dos o más datos en una expresión y evaluar el resultado de la operación.Esta característica de C/C++ permite la construcción de expresiones muy complejas de forma sencilla.

Existen 4 grupos de operadores:

Aritméticos.Los operadores artiméticos son los que realizan operaciones matemáticas, donde se implican 1 o más variables para ser sumadas, restadas, multiplicadas, divididas etcétera.

Operadores aritméticos

Operador Significado Ejemplo

+ Suma a + b

- Resta a - b

* Multiplicación a * b

/ División a / b

% Residuo a % b

Incremento y decremento.Los operadores de incremento y decremento son exclusivos y propios del lenguaje C. Estos operadores pueden aplicarse a variables, pero no a constantes o expresiones.

Operadores de incremento y decremento


Incrementa i en 1, luego se utiliza el nuevo valor de i en la expresión.

++ i

Utiliza el valor actual de i en la i ++


++ expresión y luego se incrementa en 1.

--

Decrementa i en 1 y luego utiliza el nuevo valor de i en la expresión.

-- i

Utiliza el valor actual de i en la expresión y luego se decrementa i en

1.

i --

Relacionales.Estos operadores describen una relación, condición y comparación de dos valores. El resultado que devuelve estas expresiones es de tipo booleano, es decir verdadero (1) o falso (0). La principal diferencia con respecto a otros lenguajes son los símbolos empleados en los operadores de igualdad y distinto. El de igualdad por su similitud con la asignación lleva muchas veces a provocar errores tipográficos involuntarios.

Operadores relacionales


> Mayor que 8 > 5

< Menor que 3 < 10

>= Mayor o igual que 6 >= 6

<= Menor o igual que -10 <= -5

== Igual que 1 == 1

!= Distinto de 100 != 36


Lógicos.Las expresiones lógicas tienen la posiblidad de combinarse para formar expresiones más complejas utilizando los operadores lógicos.

Operadores lógicos


&& y a && b

|| ó a || b

! No a ! b

De este modo, es importante conocer cómo evaluar las expresiones lógicas, con el uso de la llamada “tabla de la verdad” nos permite representar cómo funciona cada operador lógico.

Tabla de la verdad

a b !b A && b a || b

verdadero verdadero falso verdad verdad

verdadero falso falso falso verdad

falso verdadero verdad falso verdad

falso falso falso falso verdad

Operadores de asignaciónLos operadores de asignación permiten evaluar una expresión y asignar el resultado a la variable

Operadores de asignación


= Asignar identificador = expresión

suma = n1 + n2;


Además existen otros operadores de asignación propios del lenguaje C:

Operadores de asignación de C/C++

Operador Ejemplo Equivalencia

+= a+=7 a=a+7

-= a - =7 a=a – 7

*= a*=15 a=a*15

/= a/=2 a=a/2

%= a%=4 a=a%4

Operador condicionalEl operador condicional sustituye a la sentencia de condición “if…. else”.

Su estructura es:

Ejemplo de este operador:


IdentificadoresLos identificadores son una secuencia de caracteres ya sea alfabéticos, numéricos y además de éstos, el guíon bajo. Con los identificadores podemos otorgarle un nombre a las variables, constantes, a los tipos de datos, a las funciones o procedimientos, etcétera.

El lenguaje C no está especificado el límite del tamaño de éstas, pero en algunas implementaciones de C++ sólo se admiten los primeros 31 caracteres.

Para crear un identificador en un algoritmo se deben seguir estas normas:

El primer carácter debe ser una letra de la A a la Z, ya sea mayúscula o minúscula y no pueden contener espaciones en blanco. En este lenguaje se permite el uso de “_” (guión bajo) por lo que se puede se utilizar como letra.

No se puede utilizar una palabra reservada como identificador ya que es propia del lenguaje.

Este lenguaje puede distinguir entre mayúsculas y minúsculas por que tienen diferente código ASCII.

En un programa no se pueden nombrar dos identificadores con el mismo nombre.

Los identificadores pueden tener uno o varios puntos, según la estructura empleada.

Sin embargo, para mejorar el uso de los identificadores en los algoritmos se sugiere que:

El identificador tenga un nombre significativo, que dé una idea de la información que almacenará.

Utilizar identificadores cortos, apoyándose con abreviaturas. Para un mejor aspecto en los identificadores compuestos (más de un

nombre) se puede escribir la primera palabra en minúscula y la primera letra de la segunda en mayúscula.

De lo anteriormente dicho, he aquí unos de ejemplos sobre el uso recomendado de los identificadores:

Correcto Incorrecto

notaLabP1 1notalabp

IC2016 2016IC

Manual_C Manual C


Tipos de datosLos tipos de datos en un algoritmo son los conjunto de valores que se pueden almacenar en una variable. Éstos están delimitados por un rango de valores, si se excede ese límite de datos, el compilador no podrá ejecutar dicho programa.

El tipo de dato asociado a una variable sólo puede utilizarse con el mismo tipo de dato. Por ejemplo, una variable de tipo int no puede almacenar datos de tipo char, por lo que de igual manera no se pueden calcular operaciones con esta variable.

Los tipos de datos se asignan a las variables por dos razones principales:

Detectar errores de operaciones en los programas. Determinar cómo ejecutar las operaciones del algoritmo.

Los tipos de datos simples son los datos indivisibles, es decir, que no se pueden descomponer.

Estos datos son los: numéricos (enteros y reales), lógicos (booleanos) y caracteres.

NuméricosEste tipo de dato se divide en enteros y reales.

Tipo entero:

Son aquellos números que no tienen fracciones o decimales. Pueden ser positivos y negativos y su rango es de -32,768 a 32,767. Aunque variar según el compilador utilizado. Se almacen en la memoria RAM con un tamaño de 2 o 4 bytes según el tamaño.

Estos tipos de datos pueden ser:

unsigned int (entero sin signo) Short (entero corto) Int (entero) Unsigned long (entero largo sin signo) Long (entero largo)


Tipo reales o de coma flotante (float/double):Estos tipos de datos contienen una coma o punto decimal, pueden ser positivos y negativos. Para representar los números grandes o pequeños se puede utilizar la notación científica (número real x10 elevado a la potencia).

Estos tipos pueden ser:

float (4 bytes en memoria). double (8 bytes). long double (16 bytes).

Lógicos (booleanos en C++)

Los datos lógico/booleanos en lenguaje C/C++ además de tomar uno de los valores verdadero (true) o falso (false) se puede implementar con un número entero; el 0 como falso y 1 o cualquier otro número diferente de 0 como verdadero.

Caracteres

Los caracteres se almacenan en el interior de computadoras como “palabras” de 1 bytes (8 bits). Se representan en enteros de rango -128 a +127. En lenguaje C se puede utilizar el tipo unsigned char para representar los valores de 0 a 255, de este modo se utiliza el código ASCII. Al guardarse como números enteros, estos se pueden utilizar con operaciones aritméticas.

Void

Son datos vacíos. Este se puede emplear cuando la función main no regreas ningun valor, por lo que la reemplazamos por void main () o void main (void).


En resumen, los tipos de datos del lenguaje C/C++ se clasifican en:

Tipo de dato Descripción Tamaño (bytes)

Rango Ejemplo

int

signed entero con signo

4

-32,768 a 32,767

signed int nota=+3879

short entero corto 2 short int nota=150

long entero largo 4 -2147483648 a 2147483647 long int nota=5555555

unsigned entero sin signo 4 0 a 65535 unsigned int nota=9163

bool - valor lógico 1 false-true bool sexo=1

char- carácter 1 -128 a +127 char=’A’

unsigned caracter ASCII 1 0 a 255 unsigned char uca=15

float- coma flotante o

decimal4 3.4E-38 a 3.4E+38 float pi=3.1416

double

- decimal de doble precisión

8 1.7E-308 a 1.7E+308 double clases=9.5E+15

long decimal largo de doble precisión

16 3.4E-4932 a 1.1E+4932 long double clases=5.4E+1000


Juego de caracteres permitidosEl estándar de C++ especifica un juego básico de caracteres de código fuente que se puede usar en los archivos de código fuente. Para representar caracteres ajenos a este conjunto, los caracteres adicionales se pueden especificar mediante el uso de un nombre de carácter universal. Cuando se compila, el juego básico de caracteres de ejecución y el juego básico de caracteres anchos de ejecución representan los caracteres y las cadenas que pueden aparecer en un programa. La implementación de Visual C++ permite caracteres adicionales en el código fuente y el código compilado.

El juego básico de caracteres de código fuente consta de 96 caracteres que pueden usarse en archivos de código fuente. Este conjunto incluye el carácter de espacio, tabulación horizontal, tabulación vertical, avance de página y caracteres de control de nueva línea.

Entre estos se encuentran los caracteres del código ASCII:

El código ASCII (acrónimo inglés de American Standard Code for Information Interchange — Código Estándar Estadounidense para el Intercambio de


Información), es un código de caracteres basado en el alfabeto latino, tal como se usa en inglés moderno.


VariablesUna variable es un dato cuyo valor almacenado en memoria que se puede modificar en cualquier momento o ser conservado para ser usado en los momentos que se necesite.Como ya se ha expuesto, existen varios tipos de variables: reales, enteras, caracteres, booleanas (C++) y cadenas.El lenguaje C permite denominar libremente las variables con el nombre que el programador considere correcto, para esto se siguen las normas anteriormente dichas.

Cómo declarar una variable

Las variables que se utilicen en un algoritmo deben ser declaradas antes de ser usadas. Todas deben asociarse con un tipo de dato, identificador (nombre de la variable) y valor.

La sintaxis para definir una variable en lenguaje C es:

Si se desea inicializar una variable y asignar un valor en esa mismo momento se utiliza la siguiente estructura:

En dependencia del tipo de valor que se utiliza en un variable, se debe utilizar otras estructuras. Por ejemplo:


Para inicializar una variable tipo entero

Para inicializar una variable tipo char

Inicializar una variable char con arreglo de cadena

Como se puede observar, cuando se inicializa una variable de tipo carácter, ésta tiene que ser usada entre comillas simples ‘’ . Mientras que al inicializar una cadena de caracteres se debe especificar como arreglo, contando los caracteres de la cadena + 1 espacio más en el arreglo y entre comillas “”.

Si las variables que se quieren declarar son del mismo tipo de dato, se pueden definir en una sola línea:

Una variable puede declararse en cuatro lugares diferentes del algoritmo o programa:

• Fuera de todos los subprogramas o funciones (global).

• Dentro de un subprograma o función (local a la función).

• Dentro de un bloque enmarcado por llaves { } (local al bloque).

• Dentro de una instrucción, por ejemplo: for (int i50; i,510; i11).

• Como parámetro formal (local a la función).


Para inicializar una variable tipo float o double

ENTRADA DE DATOS: LEER DATOS.Leer datos en Lenguaje C.El lenguaje C al no tener palabras reservadas para la entrada/salida del sistema (teclado y pantalla), estas operaciones se realizan por medio de las funciones de la biblioteca <stdio.h> (standar input-output).

La función scanf() se usa para la entrada y permite leer datos a través del teclado y asignarlos a una variable del algoritmo, de acuerdo a su formato específico.

La sintaxis de la función scanf() es:

La cadena de control contiene uno o varios especificadores o códigos de formato que indican el tipo de dato de los argumentos a utilizar y su anchura. Estos códigos están precedidios por el carácter % seguido del carácter de conversión, cabe recalcar que estos siempre se escriben entre comillas “”.

Tabla de los especificadores para cada tipo de dato en scanf():

Tipo de dato Especificador de formato

char %c

char unsigned %c

char (cadena terminada en \0) %s

int %d - %i

unsigned int %u

short int %hd

unsigned short int %hu

signed short int %d

long int %ld

unsigned long int %lu

signed long int %l

float %f - %g - %G - %e - %E

double %lf - %lg - %lG - %le - %lE


long double %lf - %lg - %lG - %e - %lE

octal sin signo %o

hexadecimal minúscula %x

hexadecimal mayúscula %X

La lista de argumentos son las variables. Esta función necesita saber la posición de memoria en la que la variable se almacenará, por lo que se utiliza el símbolo ampersand (&), ubicado antes del nombre de la variable.

A continuación, estos ejemplos del uso de scanf() con sus respectivos especificadores:

Se declara la variable numAsig como entero, luego se utiliza la función scanf, entre paréntesis el especificador entre comillas, seguido del & y nombre de la variable. Esta función permitirá leer datos de tipo int desde el teclado y asignarselos a la variable.

Se declara la variable universidad como char, ésta se utilizara como cadena. A diferencia de las otros tipos de datos, al utilizar una cadena, se puede obviar el ampersand (&) por lo que simplemente sería la función scanf, seguido del especificador entre comillas y el identificador.


Una de las ventajas que posee esta función, es que permite leer distintas variables con una sola línea de código, simplificando el algoritmo. Sólo basta con agregar los especificadores e identificadores separados por coma.

SALIDA DE DATOS: IMPRIMIR DATOS

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

La sintaxis de esta función es:

Al igual que en la función scanf(), la cadena de controladores son los especificadores y los argumentos los identificadores o nombres de variables. Ademas la cadena de control debe escribirse entre comillas (“ ”) y puede tener al menos uno de estos tres elementos:

Los caracteres que se imprimirán en pantalla (los cuales se visualizarán idénticos).

Uno o varios especificadores o códigos de formato (indica de qué tipo de dato se trata, como ya se había indicado en la función scanf() ).

Secuencias de escape: estas secuencias nos permiten añadir otras características a la salida.

Secuencia de escape Descripción\a Alerta

\b Espacio atrás

\f Salto de página

\n Salto de línea

\r Retorno de carro

\t Tabulación horizontal


\v Tabulación vertical


Ejemplo de imprimir datos:

Se imprime el valor de la variable edad de tipo entero.


Los códigos de formato pueden controlar aspectos de la apariencia de los datos: la longitud, el número de decimales y la justificación a izquierda o derecha.

Sintaxis:

Los valores entre [ ] son opcionales, donde:

signo: indica si el valor aparecerá a la izquierda (signo menos), o a la derecha (por defecto).

longitud: longitud máxima del valor que aparecerá en la pantalla. precisión: indica el número máximo de decimales que tendrá el valor.

l/L: se utiliza l cuando se trata de una variable de tipo long, y L cuando es de tipo double.

Ejemplo:

Al utilizar esta función, el código de formato que se ejecuta “%4d” indica que imprimirá un número entero en cuatro posiciones o lugares, justificando a la derecha. El relleno es blanco.


FUNCIÓN SIZEOF ()La función sizeof permite mostrar en la salida de un algoritmo la cantidad de memoria que ocupa un elemento de datos, éste lo indica en bytes.

Su estructura es sencila:

Para tener una mejor percepción del funciomaniento de este operador, un ejemplo realizado en C++:

Al momento de ser compilado y ejectuado, en la salida se muestra los valores de cada valores, así como también el espacio que ocupa cada una en la memoria, utilizando la función sizeof ()


CONVERSIÓN DE DATOS O CASTING En el lenguaje C/C++ existe la posiblidad de forzar la conversión de un dato a otro tipo diferente. A esta conversión se le conoce como “cast o casting”.

Su sintaxis es:

A partir de esta tabla se puede tomar en cuenta qué datos se pueden convertir a otros datos. Algunas conversiones pueden variar según la cantidad de valores que se utilicen en las variables:

Tipo de Datosshor

tsigned Short

unsigned Short boolean

double

long double int

signed int

unsigned int

short S S S S S S S Ssigned Short S S S S S S S S

unsigned Short S S S S S S S S

bool S S S S S S S Sdouble S S S S S S S S

long double S S S S S S S Sint S S S S S S S S

signed int S S S S S S S Sunsigned int S S S S S S S S

long S S S S S S S S Ssigned long S S S S S S S S S

unsigned long S S S S S S S S Sfloat S S S S S S S S Schar S S S S S S S S S

unsigned char S S S S S S S S S


long signed longunsigned

long floatcha

runsigned

charS S S S S SS S S S S SS S S S S SS S S S S SS S S S S SS S S S S SS S S S S SS S S S S SS S S S S S S S S S SS S S S SS S S S SS S S S SS S S S SS S S S S

Al compilar y ejecutar algunos códigos utilizando el casting se puede lograr ver en la salida:


En el anterior ejemplo, se puede observar que al momento de convertir un valor de tipo int (entero) a una variable de tipo char (carácter), éste lo toma como un código ASCII por lo que en la salida muestra una arroba “@” como símbolo, ya que el éste es el número 64 en el código ASCII.


ARREGLOS Los arreglos son el tipo de dato estructurado que almacena en una sola variable un conjunto .limitado de elementos del mismo tipo. Un arreglo en lenguaje C inicia en la posición 0 (cero) por lo tanto el último elemento está en la posición i-1, es decir el número de arreglos declarados -1.

Para acceder a un elemento específico de un arreglo se usa un índice o subíndice.

Las características del arreglo son:

Ser una lista de un número finito de n elementos del mismo tipo. Almacenar los elementos del arreglo en memoria contigua. Tener un único identificador o nombre de variable que representa a todos

los elementos y éstos se diferencian por un índice o subíndice. Acceder de manera directa o aleatoria a los elementos individuales del

arreglo, por el nombre del arreglo y el índice o subíndice.

Es importante declarar los arreglos con el tamaño adecuado, ya que si un arreglo que se le 50 elementos, sólo se ocupan 10, se dejarían 40 espacios sin usar por lo que se estaría desperdiciando un lugar en la memoria.

Los arreglos se clasifican en:

Arreglo unidimensional

El 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 el valor.

La sintaxis de un arreglo unidimensional es:

Donde: 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.


Existen varias formas de inicializar los valores de los elementos de un arreglo.

Directamente con llaves: de esta forma se utiliza la sintaxis anterior y se añaden llaves para indicar los valores de cada elemento del arreglo:

Declaración por separado: se conserva la misma sintaxis, pero al asignar los valores de cada elemento se hace de modo independiente. Cada elemento debe ser indicado por su índice entre corchete [ ], empezando del 0 hasta el número de elementos -1.

La representación de como sería un arreglo en memoria es esta, tomando en cuenta el anterior arreglo:

16 64 32 8 4


[0] [1] [2] [3] [4]

ÍNDICES

Leer un arregloPara leer un arreglo se debe de indicar el subíndice del elemento al que se le va a asignar un valor. Para esto se escribe el nombre del arreglo y entre corchetes [ ] el elemento a asignar.

Ejemplo:

En lenguaje C utilizando scanf()

En lenguaje C++ utilizando cin

De este modo estamos asignando un valor de tipo entero al elemento 0 del arreglo llamado edad (edad[0])

Imprimir un arregloPara imprimir un arreglo, al igual que cuando se lee un arreglo, se debe indicar qué elemento del arreglo se debe mostrar. Para esto se utiliza el nombre del arreglo y el elemento a imprimir entre corchete [ ].

En lenguaje C utilizando printf

En lenguaje C++ utilizando cout


Al ejecutar los códigos, la salida se mostrará así:

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.

Su estructura es:

Ejemplo:

Para declarar un arreglo bidimensional se necesitan declarar dos elementos, donde el primero será el número de filas y el segundo el número de columnas.


Representado como una matriz sería:

gasolina Columna 0 Columna 1 Columna 2

Fila 0 gasolina[0][0] gasolina[0][1] gasolina[0][2]



Inicializar un arreglo bidimensionalPara inicializar un arreglo bidimensional, al igual que el unidimensional se puede realizar de varias maneras:

Directamente con llaves: de esta forma se utiliza la sintaxis anterior y se añaden llaves para indicar los valores de cada elemento del arreglo, como la matriz es de 3x3, serían 9 elementos a inicializar.

Declaración por separado: se conserva la misma sintaxis, pero al asignar los valores de cada elemento se hace de modo independiente. Cada elemento debe ser indicado por su índice entre corchete [ ], deben ser dos por cada uno ya que contiene filas y columnas, empezando del 0 hasta el número de elementos -1.


Ejemplo más avanzado:


La salida del algoritmo es:


ESTRUCTURAS

Una estructura se le denomina a un tipo de dato estructurado y definido por el usuario que permite almacenar datos de diferente tipo en una sola variable; dichos datos pueden ser simples (caracteres, números enteros o de coma flotante, etc.) o compuestos (vectores, estructuras, listas, etc.). A los datos del registro se les denomina campos, elementos o miembros. Una estructura está formada por variables que tienen relación entre sí.

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. Aunque también se puede definir la estructura y declarar variables del tipo estructura definida, lo normal es declararlas fuera de la definición. Más adelante se muestra la forma de declarar una estructura, un tipo de dato y una variable tipo registro (struct ).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. Se permite cualquier definición de tipo habitual, incluso punteros y estructuras. Cada definición de campo acabará con un punto y coma. Por último se coloca una llave derecha. Si hay campos del mismo tipo, se pueden declarar en la misma línea, separándolos por comas.

Hay varias formas de definir un registro, pero la más general es la siguiente:


Al estar definida ya la estructura, para poder acceder a ella e ingresar valores a las variables, se necesita indicar una variable a esa estructura.

De este modo:

O de igual manera, sin utilizar la palabra reservada “struct”

Ejemplo de estructuras utilizando la E/S de la cabecera stdio.h (printf-scanf)

Estructura de estudiante


Al compilar y ejecutar el código, su salida es:


Estructura de empleado


Estructura de vehículo


Salida del registro

Estructura de docente


Salida del registro

FICHEROS

Un archivo es un conjunto de bits almacenados en un dispositivo de memoria secundario, por ejemplo el disco duro (HDD), el cual es almacenado en un conjunto de propiedades, y es identificado por un nombre.

En C, se puede definir como un concepto lógico que es aplicado desde archivos de discos hasta terminales.

Los ficheros se clasifican en dos tipos:

Archivo de textoEs una secuencia de caracteres organizados en líneas terminadas y planas.

Archivo BinarioEs una secuencia de bytes que tienen una correspondencia uno a uno con un dispositivo externo.

Manejo de archivosEstos ficheros son administrados por un puntero, la cual es una variable de tipo puntero al tipo FILE con variable en “F”.

Apertura de archivosPara la apertura de archivos en C se utiliza la función fopen(), donde abre una secuencia para ser utilizada. Su sintaxis es:

Donde:

FILE*= declara un puntero a un puntero a un archivo y en dirección a memoria.

fopen() función para abirar la sentencia. nombre_archivo= nombre del puntero, puede incluir la especificación del

directorio. Modo= qué procesos se realizarán con los archivos.


Modos de apertura Existen varios modos de abrir un fichero:

Modo Descripción

r Abrir un archivo para lectura al final , el fichero debe existir.

w Abrir un archivo para escritura al final, se crea si no existe o se sobreescribe si existe.

a Abrir un archivo para escritura al final del contenido, si no existe se crea.

a+ Añade; abre o crea un fichero de texto para actualización, lee y escribiendo al final del

fichero (EOF)

a+b ó ab+ Añade; abre o crea un fichero en modo binario para actualización, escribiendo al

final del fichero (EOF)

r+ Abrir un archivo para lectura y escritura, el fichero debe existir, al inicio

w+ Crear un archivo para lectura y escritura al inicio, se crea si no existe o se sobreescribe

si existe.

r+b ó rb+ Abre un archivo en modo binario para actualización (lectura y escritura).

rb Abre un archivo en modo binario para lectura.

FuncionesLas funciones principales de ficheros son las siguientes:

Función fopen()La función fopen() devuelve un puntero a archivo para abrir la sentencia. Si se produce un error al abrir el archivo o simplemente no existe, el puntero devuelve el valor NULL.

Ejemplo:


Función fclose()La función fclose() cierra una sentencia que fue abierta anteriormente. Escribe la información que tiene en el buffer y realiza el cierre normal. En caso de producirse un error al cerrarlo, se puede generar pérdida de datos.

Su estructura es:

Un ejemplo es:

Función fseek ()La función fseek activa el indicador de posición de ficheros para el stream apuntado por stream. Para un stream binario, la nueva posición, medido en caracteres del principio del fichero, es obtenida mediante la suma de desplazamiento y la posición especificada por origen.

Su estructura es:

Donde su origen es:

La posición especificada es el comienzo del fichero si origen es SEEK_SET.

el valor actual del indicador de posición de fichero si es SEEK_CUR. Al final de fichero si es SEEK_END.

Un stream binario realmente no necesita soportar llamadas a fseek con un valor de origen de SEEK_END. Para un stream de texto, o bien desplazamiento será cero, o bien desplazamiento será un valor retornado por una llamada anterior a la función ftell al mismo stream y origen será SEEK_SET. Una llamada correcta a la función fseek despeja el indicador de final de fichero para el stream y deshace cualquier efecto producido por la función ungetc en el mismo stream. Después de una llamada a fseek, la siguiente operación en un stream de actualización puede ser de entrada o salida.

ftell ()La función ftell retorna el valor del indicador de posición de fichero para el stream, si se tiene éxito. Si falla, la función ftell retorna -1L y guarda un valor positivo, según la definición de la implementación, en errno.


Su sintaxis es:

Otras funcionesNombre Funciónfopen() Abre un archivo.

fclose() Cierra un archivo.

fgets() Lee una cadena de un archivo.

fputs() Escribe una cadena en un archivo

fseek() Busca un byte específico de un archivo.

fprintf() Escribe una salida con formato en el archivo.

fscanf() Lee una entrada con formato desde el archivo.

feof() Devuelve cierto si se llega al final del archivo.

ferror() Devuelve cierto si se produce un error.

rewind() Coloca el localizador de posición del archivo al principio del mismo.

remove() Borra un archivo.

fflush() Vacía un archivo.


ESTRUCTURAS DE CONTROL DE DATOS

Estas estructuras controlan cómo se ejecutan los programas, es decir el orden de las instrucciones, ya que tienen un solo punto de entrada y un punto de salida. En la programación estructurada se mezclan las estructuras de control y las podemos clasificar en:

Estructuras CondicionalesLas estructuras condicionales permiten realizar unas sentencias u otras dependiendo de los valores.

Sentencia If simple


Secuencial

Estructuras de Control

Es la estructura más sencilla ya que el programador identifica los datos de entrada, los procesa y muestra o imprime los datos de salida.

Selectiva

Es una estructura con una sola entrada y una sola salida en la cual se realiza una acción (una o varias instrucciones) de entre varias, según una condición; o se realiza una acción según el cumplimiento o no de una determinada condición. La condición puede ser simple o compuesta.

Repetitiva

La repetición de una acción se lleva a cabo mientras se cumpla cierta condición; para que la acción termine, la acción misma debe modificar la(s) variable(s) de control que interviene(n) en la condición. Dicha condición puede estar predefinida como en el ciclo desde (for); o no predeterminada, como en los bucles mientras (while)y hacer-mientras (do_while).

Si se cumple la condición, se ejecutan las instrucciones

Estructura Ejemplo

Condicional doble (if- else)Si se cumple la condición, se ejecuta las instrucciones del bloque if, sino se cumple se realizan las del bloque else.

Estructura Ejemplo:

Condiciones anidadas (if-else)Las condiciones anidadas consiste en realizar varias sentencias if-else dentro del else.

Estructura


SwitchPermite comparar una variable con distintos valores, ejecutando para cada caso una serie de instrucciones específicas.

Su estructura es:


Ejemplo

Estructuras repetitivasEstas instrucción son aquellas que controlan los bucles, ciclos o repeticiones de un algoritmo. En cada vuelta el ciclo comprueba si la condición es verdadera y finaliza cuando ésta sea falsa.

While Controla la ejecución de un bloque instrucciones de tal forma que éstas ejecutan mientras se cumple la condición.

Su estructura es: Ejemplo

Do-WhileEsta sentencia tiene una diferencia con respecto al while, en vez de evaluar primero la condición y depués ejecutarla, éste se ejectua primero las instrucciones y luego se evalua la condición.

Ejemplo:


ForEl desde (for) es la estructura repetitiva más utilizada y simple de manejar, ya que repite un conjunto de instrucciones un número determinado de veces. Una de sus aplicaciones principales son los arreglos.

Estructura:

Dónde:

Parte de inicialización: inicializa la variable de control del bucle, se peude usar una o más variables.

Parte de iteración o condición: es una expresión lógica, se cumple mientras sea True.

Parte de incremento: se incrementa o decrementa el valor de la variable.


PROGRAMACIÓN MODULAR

La programación modular es una técnica que consiste en dividir un programa en tareas y dar origen a la creación de pequeños programas llamados módulos, subprogramas o subrutinas con la finalidad de simplificar la elaboración y mantenimiento del mismo, donde cada módulo se codifica y se procesa de manera independiente, sin importar los detalles de otros módulos. Esto facilita la localización de un error cuando se produce. Este tipo de programación es uno de los métodos de diseño más flexibles y potentes para mejorar la productividad de un programa.

Ejemplo:

Al método que plantea la solución de un problema principal partiendo de las soluciones de sus subproblemas se le conoce como diseño descendente. Se denomina así ya que inicia en la parte superior con un problema general y el diseño específico de las soluciones de los subproblemas.

Las ventajas de la programación modular1. Facilita el diseño descendente.2. Se simplifica un algoritmo complejo.3. Cada módulo se puede elaborar de manera independiente, lo que permite

trabajar simultáneamente a


Programa Principal

Módulo 1 Módulo 2 Módulo 3

SubMódulo 1 SubMódulo 2

4. varios programadores y con ello disminuir el tiempo de elaboración del algoritmo.

5. La depuración se lleva a cabo en cada módulo.6. El mantenimiento es más sencillo.7. Creación de bibliotecas con módulos específicos (se pueden utilizar en otros

programas).

Función main()El papel más importante del programa principal main() es coordinar a las otras funciones mediante llamadas invocaciones. Mediante la sentencia return, el programa puede devolver un código de terminación al proceso de llamada

FuncionesEs un subprograma que realiza una tarea específica que puede o no recibir valores (parámetros). En C podemos devolver cualquier tipo de datos escalares (puntero, tipo numérico y el tipo carácter o en su caso regresar un valor nulo que llamaremos nada o ninguno). Asimismo, no se pueden devolver arreglos ni estructuras.

El uso de funciones es una práctica común y recomendable ya que permite dividir el código, simplificando así el desarrollo y la depuración del mismo. Para utilizar funciones en un programa es necesario declararlas previamente.

Ejecución de FuncionesEl compilador siempre inicia con la primera instrucción que encuentra en el programa principal (main) y continúa ejecutándolo según la estructura de control (secuencial, selectiva o repetitiva) del programa; cuando encuentra la llamada a una función éste se traslada y ejecuta el cuerpo de la función desde la primera instrucción hasta encontrar el fin de la misma; cuando esto sucede el compilador regresa a la siguiente instrucción que llamó a la función y continúa de la misma manera.

Llamada o invocación de una funciónPara llamar una función es necesario escribir el nombre o identificador de la función y en seguida un par de paréntesis, que estarán vacíos si hablamos de funciones sin paso de parámetros y tendrán información en caso de ser funciones con paso de parámetros.


Prototipo de una funciónUn prototipo es el encabezado de una función, es decir la primera línea de la función. La ventaja de utilizar prototipos es que las funciones pueden estar en cualquier lugar y en cualquier orden y pueden ser llamadas desde cualquier punto del programa principal o de otra función.

Ejemplo de la sintaxis:

Argumentos de FuncionesSon variables locales conocidas como parámetros formales y se utilizan como un medio para entregarle información a la función.

Los parámetros formales reciben sus valores iniciales desde los parámetros reales, es decir desde los valores que se les pasan a través de la llamada.

Se declara de esta forma:

Se llama o invoca:

Forma de transferir argumentosPase por valor: copia el valor de un argumento de la llamada en el parámetro formal de la función. Por lo tanto, los cambios en los parámetros de la función no afectan a las variables que se usan en la llamada.

Pase por referencia: se copia la dirección del argumento en el parámetro. Los cambios hechos a los parámetros afectan a las variables usadas en la llamada a la función.

Declaración de variables globales y constantesLas constantes y variables son elementos que tienen el objetivo de identificar los datos que se utilizan en las operaciones y cálculos que realiza el programa y que se almacenan en la memoria de la computadora. Si las variables globales son declaradas en esta parte, pueden ser utilizadas en todo el programa.

El uso de variables globales no es aconsejable a pesar de que aparentemente nos parezca muy útil, esto se debe a varias razones fundamentales:

Legibilidad menor.


Nos condiciona en muchos casos que el programa sólo sirva para un conjunto de casos determinados.

El uso indiscriminado de variables globales produce efectos colaterales. Esto sucede cuando existe una alteración no deseada del contenido de una variable global dentro de una función, bien por invocación, bien por olvidar definir en la función una variable local o un parámetro formal con ese nombre. La corrección de dichos errores puede ser muy ardua.

Atenta contra uno de los principios de la programación, la modularidad. El bajo acoplamiento supone no compartir espacios de memoria con otras funciones, y potenciar el paso de información (llamadas) para que la función trate la información localmente.


Manual C/C++ Néstor Flores

Technology

Transcript of Manual C/C++ Néstor Flores