Programación;
Nota importante: para los que no saben nada de nada, ponganse a leer un libro de c++, No el libro de c por que el libro c es su antecesor y no se usa tanto como el libro del c++, cualquiera que diga libro c++...
Para copiar y pegar en Visual basic o el que yo uso codeblocks lo malo es que esta en ingles este ultimo, tengo un monton de tarea ahora que estoy en la universidad asi que tratare de mejorar este post.
con los comentarios iré acomodando mejor este post, si me falta algo o de pura casualidad me equivoque avísenme.
Nota: Estos códigos los lleve en clase así que a mi si me salieron y deberían funcionar...
Resumen de la semana
En esta semana se estudiaran los conceptos básicos de las clases de entra y salida
cin y cout
También se estudiaran las estructuras de control de programa
for()
while()
do-while()
if ()
1.Estructura básica de un programa en lenguaje C++
Para estructurar un programa en C++, se puede seguir el siguiente esquema básico
//Comentarios
# inclusiones <> y cabeceras
declaración de variables globales
main ()
{
cuerpo del programa principal
}
Comentarios. Los comentarios son elementos que permiten al programador etiquetar partes del programa, y de esta forma identificar o establecer puntos de referencia que le faciliten la lectura del programa. En lenguaje C++ existen dos tipos de comentarios, el comentario por bloques y el comentario de una sola linea. El primero utiliza los símbolos /* para el inicio del bloque y */ para el cierre del bloque. El segundo solo utiliza los símbolos //.
Inclusiones. Las inclusiones son una directiva del compilador que permiten la concatenación de un código previamente escrito con el código actual. Para indicarle al compilador que incluya dentro del proceso de compilación y ensamblado de nuestro código una cabecera o una biblioteca es necesario utilizar la directiva #include seguido de los símbolos <> o " ".
Declaración de variables globales. En esta sección del código, se declaran todas las variables que serán utilizadas a lo largo del programa.
Cuerpo del programa principal. Como su nombre lo indica, este es el programa principal, aquí es donde se escriben todas las instrucciones que darán funcionalidad al código.
2. Clases de entrada y salida cin y cout
Los objetos cin y cout permiten la inserción y extracción de datos desde y hacia la consola de salida (monitor, teclado, etc.).
cin. Este objeto inserta datos desde fuera hacia dentro del programa la sintaxis utilizada es la siguiente cin >> nom_variable; , donde nom_variable es la variable donde será asignado el dato.
cout. Este objeto extrae datos desde dentro del programa hacia una consola de salida la sintaxis utilizada es la siguiente cout << dato_salida;
Ejemplo 2.1
/*************************************************************
* Este el primer programa de ejemplo *
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
using namespace std;
int main (void)
{ cout << "Este es mi primer progrma en C++";
return 0;
}
Ejemplo 2.2
En el ejemplo anterior, se muestra un código muy simple que envia un mensaje a la pantalla utilizando el objeto cout. En este nuevo ejemplo se mostrara el uso del objeto cin, también se hara uso por primer vez de la inicialización de una variable donde se almacenará el dato de entrada.
/*************************************************************
* Este es el segundo programa de ejemplo *
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
using namespace std;
int main (void)
{ int var_1; //se declara la variable de entrada tipo entera
cout << "Ingrese un numero entero: ";
cin >> var_1; // inserta desde el teclado un valor a la variable
cout << "El numero que ingreso es: " << var_1;
return 0;
}
Tipos de datos
C++ tiene los siguientes tipos fundamentales:
Caracteres: char (también es un entero), wchar_t
Enteros: short int, int, long int, long long int
Números en coma floante: float, double, long double
Booleanos: bool
Vacío: void
El modificador unsigned se puede aplicar a enteros para obtener números sin signo (por omisión los enteros contienen signo), con lo que se consigue un rango mayor de números naturales.
3. Ciclos
Los ciclos son usados para repetir un bloque de código. Una de las tareas mas básicas en lenguaje C++ es, hacer que el programa ejecute de manera repetida un bloque de codigo. Dentro de los ciclos podemos definir tres tipos:
for()
while()
do-while()
3.1 Ciclo for()
El ciclo for() es uno de los mas utilizados. La sintaxis para es esta funcion es:
for ( inicializacion de la variable; condicion; incremento de la variable )
{
codigo a ejecutar, mientras la condicion es cierta
}
La iniciaización de la variable, permite tanto declarar una varible, asi como darle valor a una variable ya existente. La condición, le indica al programa que mientras la condicional de la expresión es cierta, el ciclo debe de continuar de manera repetida. El incremento de la variable permite mantener un cambio en la variable. Es importante notar que cada sección esta separada por "punto y coma". Aun cuando cada una de las secciones puede estar vacía, el punto y coma debe de estar presente.
EJEMPLO 3.1: se desea imprimir en pantalla la tabla de multiplicar de un número X.
/*************************************************************
* programa de ejemplo ciclo for() *
* imprime en pantalla la tabla de mutiplicar de
* un numero x
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
using namespace std;
int main (void)
{
for (int a = 1;a <= 10; a++)
cout << "5 x" << a << " = " << 5*a;
return 0;
}
3.2 Ciclos while() y do-while()
Ciclo while(). La sintaxis de este ciclo es
while (condicion)
{
codigo a ejecutar mientras la
condicion es cierta
}
A continuación se muestra el código para el ejemplo 3.1 ahora utilizando el
ciclo while()
Ejemplo 3.2
/*************************************************************
* programa de ejemplo ciclo while() *
* imprime en pantalla la tabla de mutiplicar de
* un numero x
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
using namespace std;
int main (void)
{
int a = 1;//inicializacion de la variable
while (a <= 10)
{
cout << "5 x" << a << " = " << 5*a;
a++; // actualizacion de la variable
}
return 0;
}
Ciclo do-while(). La sintaxis de este ciclo es
do
{
codigo a ejecutar mientras la
condicion es cierta
}while (condicion);
A continuación se muestra el código para el ejemplo 3.1 ahora utilizando el
ciclo do-while()
Ejemplo 3.3
/*************************************************************
* programa de ejemplo ciclo do-while() *
* imprime en pantalla la tabla de mutiplicar de
* un numero x
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
using namespace std;
int main (void)
{
int a = 1;//inicializacion de la variable
do
{
cout << "5 x" << a << " = " << 5*a;
a++; // actualizacion de la variable
}while (a <= 10);
return 0;
}
4. Estructura de control if()
La capacidad de controlar el flujo de un programa, ofrece la posibilidad de decidir que parte del código ejecutar. En lenguaje C++ la instrucción if(), permite controlar si un programa entra o no a una sección especifica del codigo, basado en sí una condición dada es VERDADERA o FALSA.
Una de las funciones mas importantes de la instrucción if(), es permitir al programa seleccionar una acción determinada, basado en los datos proporcionados por el usuario.
Antes de discutor la estructura de la instrucción if(), vamos primero a examinar el significado de FALSO y VERDADERO, dentro de la terminología computacional. Una instrucción VERDADERA, es aquella que evalúa a un número NO CERO, una instrucción FALSA evalúa a un número CERO. Al realizar una comparación con operadores relacionales, el operador puede retornar 1 si la comparación es VERDADERA o 0 si la comparación es FALSA.
A continuación, se muestran algunos operadores relacionales
> mayor que 5 > 4 VERDADERO
< menor que 4 < 5 VERDADERO
>= mayor o igual que 4 >= 4 VERDADERO
<= menor o igual que 3 <= 4 VERDADERO
== igual a 5 == 5 VERDADERO
!= diferente que 5 != 4 VERDADERO
La sintaxis de la instrucción if() es
if ( VERDADERO )
ejecuta este segmento de codigo
Ejemplo 4.1
/*************************************************************
* programa de ejemplo if() *
*
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
using namespace std;
int main (void)
{
if (5 < 10)
cout << "5 es menor que 10" ;
return 0;
}
Esta semana 17 de February - 23 de February
Resumen de la semana
En esta semana estudiaremos los conceptos de arreglos, punteros, entrada y salida de datos en archivos.
5. Arreglos.
Los arreglos son una colección ordenada de elementos de un mismo tipo. Ordenada significa que cada elemento tiene una ubicación determinada dentro del arreglo y debemos conocerla para poder accederlo.
Para comenzar a estudiar los arreglos, iniciaremos con el arreglo mas simple, el arreglo unidimensional.
Sintaxis:
<tipo> nombre_variable[longitud];
Con esto diremos que nombre_variable es un arreglo de longitud elementos del tipo <tipo>. Cabe destacar que longitud debe ser cualquier expresión entera constante mayor que cero.
Asignación de un arreglo: Para asignar valores a un arreglo es necesario introducir el valor correspondiente a cada elemento.
nombre_variable[índice] = expresión del tipo <tipo>
Debemos notar que longitud e índice, tienen funciones completamente diferentes. En otras palabras, el valor de longitud según la sintaxis anterior, define el tamaño del arreglo, mientras que índice, define el lugar que le correspondo a un elemento dentro del arreglo.
Para entender mejor el concepto vamos a plantear el siguiente ejemplo:
Ejemplo 5.1
Se desea guardar en memoria el siguiente conjunto de números enteros {1, 5, 3, 9, 3, 6, 7, 3, 2, 7 }. Podemos notar que el tamaño del conjunto es de 10 y que todos son números enteros, entonces para poder desarrollar el código en lenguaje C++ que almacene el conjunto anterior, definiremos que:
Longitud o tamaño del arreglo = 10
tipo = int
/*************************************************************
* programa de ejemplo arreglos*
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
using namespace std;
int main (void) { int numeros_enteros[10];
// declaramos un arreglo tipo entero de longitud 10
numeros_enteros[0] = 1;
numeros_enteros[1] = 5;
numeros_enteros[2] = 3;
numeros_enteros[3] = 9;
numeros_enteros[4] = 3;
numeros_enteros[5] = 6;
numeros_enteros[6] = 7;
numeros_enteros[7] = 3;
numeros_enteros[8] = 2;
numeros_enteros[9] = 7;
return 0;
}
Ejemplo 5.2
Una variante del ejemplo 5.1 se muestra a continuación
/*************************************************************
* programa de ejemplo arreglos*
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
using namespace std;
int main (void)
{
int numeros_enteros[10] = {1, 5, 3, 9, 3, 6, 7, 3, 2, 7 };
// declaramos un arreglo tipo entero de longitud 10
return 0;
}
Ejemplo 5.3
Desarrollar un programa que permita ingresar 10 datos desde el teclado y los almacene dentro de
un arreglo de tipo entero.
Solución:
Definimos primero la longitud del arreglo, longitud = 10, para poder ingresar los datos de una manera ciclica desde el teclado, haremos uso de un ciclo for().
/*************************************************************
* programa de ejemplo arreglos*
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
#define longitud 10 //usaremos las directiva define para
// definir el tamaño del arreglo
using namespace std;
int main (void)
{
int numeros_enteros[longitud];
// declaramos un arreglo tipo entero de longitud 10
for (int a = 0; a < longitud; a++)
cin >> numeros_enteros[a];
return 0;
}
Usos de arreglos unidimensionalesTarea
5.1 Arreglos Bi-dimensionales
Como se mencionó anteriormente, un arreglo es un conjunto ordenado de datos,
ahora estudiaremos los arreglos bi-dimensionales. Estos arreglos agrupan los datos en forma de una
matriz i x j.
Sintaxis:
<tipo> nombre_variable[longitud_i][longitud_j];
Con esto diremos que nombre_variable es un arreglo de longitud_i x longitud_j elementos del tipo <tipo>. Cabe destacar que longitud_i y longitud_J deben de ser cualquier expresión entera constante mayor que cero.
Asignación de un arreglo: Para asignar valores a un arreglo es necesario introducir el valor correspondiente a cada elemento.
nombre_variable[índice_i][índice_j] = expresión del tipo <tipo>
Ejemplo 5.4
Para entender mejor el uso de los arreglos bi-dimensionales, vamos a desarrollar un programa que realice la suma de dos matrices de [nxn] elementos.
Solución: en términos del álgebra lineal, la suma de matrices esta definida como la suma de cada uno de los elementos de una matriz dada con su correspondiente. Esto es, si tenemos la matriz A que contiene los elementos a11, a12, a13, ..., anm y una matriz B que contiene los elementos b11, b12, b13, ..., bnm , entonces la suma de A + B da como resultado una matriz donde sus elementos son a11+ b11, a12 + b12,
a13 + b13, ..., anm + bnm .
El código que realiza la operación antes mencionada es el siguiente:
/*************************************************************
* programa de ejemplo arreglos*
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
#define longitud_i 3 //usaremos las directiva define para
#define longitud_j 3
// definir el tamaño del arreglo
using namespace std;
int main (void)
{
int matrizA[longitud_i][longitud_j],
matrizB[longitud_i][longitud_j],
matrizC[longitud_i][longitud_j];
// declaramos un arreglo tipo entero de longitud 10
cout << "Ingrese lo elementos de la matriz A" << endl;
for (int i = 0; i < longitud_i; i++)
for (int j = 0; j < longitud_j; j++)
cin >> matrizA[j];
cout << "Ingrese lo elementos de la matriz B" << endl;
for (int i = 0; i < longitud_i; i++)
for (int j = 0; j < longitud_j; j++)
cin >> matrizB[j];
// realiza la suma de las matrices y guarda el resultado en
// la matrizC
for (int i = 0; i < longitud_i; i++)
for (int j = 0; j < longitud_j; j++)
matrizC[j] = matrizA[j] + matrizB[j];
return 0;
}
6. Entrada y salida a ficheros
Para el manejo de ficheros o archivos, C++ ofrece varias clases, en este curso estudiaremos la clase fstream.
Sintaxis
ifstream nombre_variable("/path/nombre_del _archivo.extension", ifstream::in);
Dentro de la sintaxis anterior podemos identificar lo siguiente, la clase ifstream, nombre de la variable, este es el nombre con el cual el archivo sera identificado a lo largo del programa, "/path/nombredelarchivo.extension", este es el nombre real del archivo y la ubicación donde sera grabado, el ultimo parámetro, indica el modo de apertura del archivo.
app (append) Para añadir al final del fichero. Todas las escrituras que hagamos se iran al final del fichero. Si nos movemos por el fichero a una posición concreta (con el método seekp()) y luego escribimos, también se escribirá al final del fichero, ignorando la posición actual en la que nos situemos con seekp().
ate (at end). Para añadir al final del fichero. Sin embargo, si nos movemos a otra posición del fichero (con seekp()) y escribimos, la escritura se hará en la posición en la que nos pongamos, y no al final como en el caso anterior.
binary (binary) Se abre el fichero como fichero binario. Por defecto se abre como fichero de texto.
in (input) El fichero se abre para lectura.
out (output) El fichero se abre para escritura
trunc (truncate) Si el fichero existe, se ignora su contenido y se empieza como si estuviera vacio. Posiblemente perdamos el contenido anterior si escribimos en él.
Ejemplo 6.1
/*************************************************************
* programa de ejemplo ficheros*
* (c) 2010 Roger Chiu Zarate *
**********************************************************/
#include <iostream>
#include <fstream>
using namespace std;
int main (void)
{
fstream f("ejemplo_6_1.txt", fstream::out);
// creamos un archivo para escritura
// el archivo se creara en el directorio actual
f << "hola mundo"; // enviamos una cadena al fichero
f.close(); //cerramos el fichero
return 0;
}
El ejemplo 6.1 crea un archivo llamado ejemplo_6_1.txt en el directorio actual,
para esto hacemos uso de la biblioteca fstream y de la clase del mismo nombre.
Hay mas pero tengo un montón de tarea luego los posteo aquí mismo..
En progreso.....