Tag Archives: #include

#Mastery17 – Use of “switch” as a conditional

Posted on 06/05/2015 by | Comments Off on #Mastery17 – Use of “switch” as a conditional

Uso del switch

En el caso de la sentencia switch, la expresión a evaluar será entera, por lo tanto, el número de opciones es mucho mayor, y en consecuencia, también es mayor el número de diferentes sentencias que se pueden ejecutar.

Sintaxis:

Cuando se usa la sentencia switch el control se transfiere al punto etiquetado con el case cuya expresión constante coincida con el valor de la expresión entera evaluada dentro del switch. A partir de ese punto todas las sentencias serán ejecutadas hasta el final del switch, es decir hasta llegar al “}”.

Esto es así porque las etiquetas sólo marcan los puntos de entrada después de una ruptura de la secuencia de ejecución, pero no marcan los puntos de salida.

Esta estructura está diseñada para ejecutar cierta secuencia de instrucciones, empezando a partir de un punto diferente, en función de un valor entero y dejando sin ejecutar las anteriores a ese punto.

Ejemplo:

 

      main() {

        char ch;

          printf(“Introduzca una vocal: “); 

 

          ch=getchar(); 

 

Comments Off on #Mastery17 – Use of “switch” as a conditional

Posted in Blogs, Syndicated, TC1017 Blogs

Tagged , , , , , , ,

#TC1017 #Mastery14

Posted on 06/05/2015 by | Comments Off on #TC1017 #Mastery14

Creating your own libraries is really usefull to include a lot with ease.

It is relatively easy to create your own libraries, you just create you file named “mylibrary.cpp” and “a.h”. Then compile the library without a main program; this will create a file called “a.o”. After that you can your program with a main program and call your library as you would with any onther (#include ). Compile the program and add the library “a.o”. 

PS.- I saw another post where it said that could also act as a library.

 

Comments Off on #TC1017 #Mastery14

Posted in Blogs, Syndicated, TC1017 Blogs

Tagged ,

#Mastery21 – Use of recursion for repetitive algorithms

Posted on 06/05/2015 by | Comments Off on #Mastery21 – Use of recursion for repetitive algorithms

Recursividad 

Una función es recursiva cuando se define en función de si misma, pero no todas la funciones pueden llamarse a si mismas. Deben estar diseñadas especialmente para que sean recursivas, de otro modo podrían conducir a bucles infinitos, o a que el programa termine inadecuadamente.

C++ permite la recursividad. Cada vez que se llama a una función, se crea un juego de variables locales, de este modo, si la función hace una llamada a si misma, se guardan sus variables y parámetros, usando la pila, y la nueva instancia de la función trabajará con su propia copia de las variables locales. Cuando esta segunda instancia de la función retorna, recupera las variables y los parámetros de la pila y continua la ejecución en el punto en que había sido llamada.

Por ejemplo:

Prodríamos crear una función recursiva para calcular el factorial de un número entero.

El factorial se simboliza como n!, se lee como “n factorial”, y la definición es:

Para este ejemplo no es posible calcular el factorial de números negativos, no está definido.

Debemos de tomar en cuenta que el factorial de cero es 1. De modo que una función bien hecha para cálculo de factoriales debería incluir un control para esos casos:

La recursividad consume muchos recursos de memoria y tiempo de ejecución, y se debe aplicar a funciones que realmente le saquen partido.

También existen otras formas de implementar algoritmos recursivos, por lo que no es necesario que una función se invoque a si misma.

Ejemplo: un par de funciones A y B pueden crear un algoritmo recursivo si la función A invoca a la función B, y esta a su vez invoca a la función A.

Veamos un ejemplo. Partamos de la siguiente serie:

Aqui tenemos otro ejemplo aun mas complejo:

using namespace std;

double par(int);

double impar(int);

double suma(int);

int main() {

    cout

    cout

    cout

    cout

    cout

    cout

    return 0;

}

double suma(int n) {

    if(n % 2) return impar(n);

    else return par(n);

}

double par(int n) {

    return impar(n-1)-1/double(n);

}

double impar(int n) {

    if(n == 1) return 1;

    return par(n-1)+1/double(n);

}

 

Referencias: http://c.conclase.net/curso/?cap=024

21 1017

Comments Off on #Mastery21 – Use of recursion for repetitive algorithms

Posted in Blogs, Syndicated, TC1017 Blogs

Tagged , , , , , , ,

#Mastery23 – Creation and use of vectors in C++

Posted on 06/05/2015 by | Comments Off on #Mastery23 – Creation and use of vectors in C++

Creación y uso de vectores en C++

Un vector, también llamado array(arreglo) unidimensional, es una estructura de datos que permite agrupar elementos del mismo tipo y almacenarlos en un solo bloque de memoria juntos, uno despues de otro. A este grupo de elementos se les identifica por un mismo nombre y la posición en la que se encuentran. La primera posición del array es la posición 0.

Podríamos agrupar en un array una serie de elementos de tipo enteros, flotantes, caracteres, objetos, etc.

Crear un vector en C++ es sencillo, seguimos la siguiente sintaxix: Tipo nombre[tamanyo];

Aqui tenemos varios ejemplos:

inta[5]; // Vector de 5 enteros
floatb[5]; // vector de 5 flotantes
Producto product[5]; // vector de 5 objetos de tipo Producto

Otra manera para inicializar el vector en la declaración es la siguiente:

1
2
3
int a[] = {5, 15, 20, 25, 30};
float b[] = {10.5, 20.5, 30.5, 12.5, 50.5}
Producto product[] = {celular, calculadora, camara, ipod, usb}

Debido a que tenemos 5 elementos en cada array, automáticamente se le asignará 5 espacios de memoria a cada vector, pero si trato de crear el vector de la forma int a[] , el compilador mostrará un error, porque no tiene indicado el tamaño del vector ni tampoco sus elementos.

Tambien podemos asignarle valores a los elementos de un vector indicando su posición:

inta[4] = 30; // le asigno el valor 30 a la posición 4 del vector.
product[2].setPrecio(300) // le asigno un precio de 300 al producto en la posición 2.

Algo muy útil para llenar, recorrer e imprimir un vector es el uso de el bucle for:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
using namespace std;
 
int main()
{
  int dim;
  cout "Ingresa la dimension del vector"
  cin >> dim; // Supongamos que ingrese 10
  int vector[dim]; // mi vector es de tamanyo 10
 
  for(int i = 0; i
    vector[i] = i * 10;
    cout
  }
 
  return 0;
}

La salida de este programa nos mostrará: 0 10 20 30 40 50 60 70 80 90.

Enseguida tenemos una función simple para sumar 2 vectores a y b y poner el resultado en un tercer vector c:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
using namespace std;
 
void sumar(int a[], int b[], int c[],int dim) {
    for (int i = 0; i
        c[i] = a[i] + b[i];
    }
}
 
void imprimir(int v[], int dim)
{
   for(int i = 0; i
        cout
   }
   cout
}
 
int main()
{
    int dim;
    cout "Ingresa la dimensión"
    cin >> dim;
 
    int a[dim];
    int b[dim];
    int c[dim];
 
    for(int i = 0; i
        a[i] = i * 10;
        b[i] = i * 5;
    }
 
    cout "Vector A "
    imprimir(a, dim);
 
    cout "Vector B "
    imprimir(b, dim);
 
    sumar(a, b, c, dim);
    cout "Vector C "
 
    imprimir(c, dim);
    return 0;
}

En resumen:

  • Todo vector debe tener definido un tipo de dato.
  • Todo vector necesita de una dimensión o tamaño.

 

Referencias: https://ronnyml.wordpress.com/2009/07/04/vectores-matrices-y-punteros-en-c/

23 1017

Comments Off on #Mastery23 – Creation and use of vectors in C++

Posted in Blogs, Syndicated, TC1017 Blogs

Tagged , , , , , , , , ,

#Mastery25 – Creation and use of strings in C++

Posted on 06/05/2015 by | Comments Off on #Mastery25 – Creation and use of strings in C++

Creación y uso de strings en C++

Una de las utiliidades de C++ es la existencia de “strings” (cadenas de texto) como parte del lenguaje.

A continuación veremos su manejo primero con un ejemplo sencillo:

 

El manejo básico de las cadenas no presenta alguna dificultad:

  • Se declaran como cualquier otra variable( string cadena )
  • Se les asigna valor con el signo = , como se hace con los números enteros.
  • Su valor se muestra en pantalla con “cout”, igual que para las demás variables.

Así que veamos otro ejemplo un poco más complejo: 

La explicación para el código seria la siguiente:

  • Se puede crear una cadena sin valor inicial haciendo string texto1;
  • Se le puede dar una valor inicial a la vez que se declara, haciendo string texto2 = “Hola “; o bien string texto3(“Que tal”);
  • Se puede crear una cadena formada por varias, concateándolas (sumándolas), usando el signo +, así: texto1 = texto2 + texto3 + ” estas? “;
  • Se puede crear una subcadena a partir de un trozo de otra, la vez que se declara, así: string subcadena (texto1, 2, 6);
  • O bien se puede extraer un fragmento posteriormente: texto1.substr(0, 5);
  • Se puede insertar texto en el interior de una cadena: texto1.insert(5, “Juan “);
  • O reemplazar ciertas letras por otras: texto2.replace(1, 2, “ad”);
  • Se puede saber el tamaño (cantidad de letras) de la cadena: texto1.size()
  • Se puede acceder a una posición siguiendo el estándar de C: texto1[2]
  • O bien usando la función “at”: texto1.at(2)
  • Se puede comprobar el valor de una cadena (el texto almacenado) con ==, así: if (texto2 == “Hada “) …

 

Referencias: http://www.aprendeaprogramar.com/mod/resource/view.php?id=172

25 1017

Comments Off on #Mastery25 – Creation and use of strings in C++

Posted in Blogs, Syndicated, TC1017 Blogs

Tagged , , , , , , , , , , ,

#Mastery27 – Validated user input in C++

Posted on 06/05/2015 by | Comments Off on #Mastery27 – Validated user input in C++

Validar inputs de usuario en c++

En C++ tenemos la opcion de validar datos alfanumericos o los llamados strings. Estos inputs se comportan como cualquier número, por lo que su uso no es muy dificil. Primero debemos conocer las reglas básicas:

Reglas basicas:

  • No deje pasar los datos no válidos en adelante
  • Validar los datos en el momento de entrada.
  • Siempre dar la retroalimentación significativa usuario
  • Dígale al usuario lo que usted espera de leer como entrada

Ejemplos:

/* example one, a simple continue statement */
  

main()
{
	int     valid_input;    /* when 1, data is valid and loop is exited */
	char    user_input;     /* handles user input, single character menu choice */

	valid_input = 0;
	while( valid_input == 0 ) {
		printf("Continue (Y/N)?n");
		scanf("  %c", &user_input );
		user_input = toupper( user_input );
		if((user_input == 'Y') || (user_input == 'N') )  valid_input = 1;
		else  printf("07Error: Invalid choicen");
	}
}
Salida del programa:
Continuar (Y / N) ?
b
Error: eleccion no válida
Continuar (Y / N) ?
N


 

Aqui otro ejemplo:

/* example two, getting and validating choices */
  

main()
{
	int     exit_flag = 0, valid_choice;
	char    menu_choice;
	
	while( exit_flag == 0 ) {
		valid_choice = 0;
		while( valid_choice == 0 ) {
			printf("nC = Copy FilenE = ExitnM = Move Filen");
			printf("Enter choice:n");
			scanf("   %c", &menu_choice );
			if((menu_choice=='C') || (menu_choice=='E') || (menu_choice=='M'))
				valid_choice = 1;
			else
				printf("07Error. Invalid menu choice selected.n");
		}
		switch( menu_choice ) {
			case 'C' : ....................();    break;
			case 'E' : exit_flag = 1;  break;
			case 'M' : ....................();  break;
			default : printf("Error--- Should not occur.n"); break;
		}
	}
}


Salida del programa 
C = Copiar archivo
E = Salir
M = Mover archivo
Introduzca elección :
x
Error . Opción de menú seleccionada no válida 
C = Copiar archivo
E = Salir
M = Mover archivo
Introduzca elección :
E

 

Referencias: http://ftp.tuwien.ac.at/languages/c/programming-bbrown/c_032.htm

27 1017

Comments Off on #Mastery27 – Validated user input in C++

Posted in Blogs, Syndicated, TC1017 Blogs

Tagged , , , , ,

#Mastery 28 – Reading and writing of files in C++

Posted on 06/05/2015 by | Comments Off on #Mastery 28 – Reading and writing of files in C++

Manejo de archivos en c++

Para manejar archivos dentro de c++ tenemos que utilizar el archivo de cabecera fstream.h. Este define las clases ifstream, ostream y fstream para poder realizar operaciones de lectura, escritura y lectura/escritura en archivos respectivamente. Para trabajar con archivos se tienen que crear objetos de éstas clases, según las operaciones que deseamos efectuar. Iniciaremos con las operaciones de escritura, para esto tenemos que declarar un objeto de la clase ofstream, después utilizaremos la función miembro open para abrir el archivo, escribimos en el archivo los datos que sean necesarios utilizando el operador de inserción y por último cerramos el archivo por medio de la función miembro close, como podemos ver en el siguiente ejemplo:

int main()
{
    ofstream archivo;  

    archivo.open();

    archivo endl;
    archivo endl;
    archivo endl;

    archivo.close();
    return 0;
} 

En el programa se ha creado un objeto de la clase ofstream llamado archivo, posteriormente se utiliza la función miembro open para abrir el arcivo especificado en la cadena de texto que se encuentra dentro del paréntesis de la función. Podemos invocar a la función constructora de clase de tal manera que el archivo también se puede abrir utilizando la siguiente instrucción:

 



Al utilizar la función constructora no es necesario utilizar la función miembro open. De la misma forma que se utilizan manipuladores de salida para modificar la presentación en pantalla de los datos del programa,es posible utilizar éstos manipuladores al escribir datos en un archivo como lo demuestra el programa archiv02.cpp, observe que se utiliza un constructor para crear y abrir el archivo llamado Datos.txt:

int main()
{
    ofstream archivo();  int numero;
    
    cout endl;
    cin >> numero;
    archivo numero endl;
    
    archivo resetiosflags(ios::dec);
    archivo setiosflags(ios::oct);
    archivo numero endl;
    
    archivo resetiosflags(ios::oct);
    archivo setiosflags(ios::hex);
    archivo numero endl;
    archivo setiosflags(ios::uppercase|ios::showbase);
    archivo 
numero endl;
    
    archivo resetiosflags(ios::uppercase|ios::showbase);
    archivo resetiosflags(ios::hex);
    archivo setiosflags(ios::showpos|ios::showpoint|ios::fixed);
    archivo numero endl;
    
    archivo resetiosflags(ios::showpos|ios::showpoint|ios::fixed);
    archivo numero endl;
    
    archivo.close();

    return 0;
} 

 

Operaciones de lectura de archivos 
Para abrir un archivo y realizar operaciones de lectura se crea un objeto de la clase ifstream y se procede prácticamente de la misma forma que lo expuesto en el apartado anterior. Después de abrir el archivo se puede leer su contenido utilizando las funciones miembro de la clase ifstream o bién el operador de extracción. Cuando se lee un archivo, por lo general se empieza al principio del mismo y se leerá su contenido hasta que se encuentre el final del archivo. Para determinar si se ha llegado al final del archivo se puede utilizar la función miembro eof como condición de un bucle while. Además se puede utilizar la función miembro fail para detectar un error al abrir el archivo, esto se demuestra en el siguiente programa, archiv03.cpp:

int main()
{
    ifstream archivo(, ios::noreplace);
    char linea[128];
    long contador = 0L;

    if(archivo.fail())
    cerr endl;
    else
    while(!archivo.eof())
    {
        archivo.getline(linea, sizeof(linea));
        cout linea endl;
        if((++contador % 24)==0)
        {
            cout ;
            cin.get();
        }
    }
    archivo.close();
    return 0;
} 

El programa crea un objeto de la clase ifstream para abrir el archivo llamado Pruebas.txt utilizando el constructor de clase y especificando la bandera ios::noreplace que evita que el archivo sea sobreescrito. Si por algún motivo ocurre un error al abrir el archivo se genera el mensaje de error especificado en la línea 16. En ausencia de errores el programa entra en un bucle while el cual está evaluado por efecto de la función miembro eof( ) de tal manera que el bucle se ejecuta hasta encontrar el final del archivo. Utlizando la función miembro getline( ) se obtiene una línea de texto y se exhibe en pantalla, línea 21, luego utilizamos una instrucción condicional if con el operador de módulo (%) para determinar si se han leído 24 líneas de texto. Cada vez que el contador de líneas dividido entre 24 dé como resultado un resíduo de cero el programa se detiene permitiendo leer las 24 líneas de texto previas. Para continuar se debe presionar la tecla enter y entonces el programa leerá y mostrará en pantalla las siguientes 24 líneas de texto, líneas 22 a la 26.

 

 

Referencias:

http://www.programacionenc.net/index.php?option=com_content&view=article&id=69:manejo-de-archivos-en-c&catid=37:programacion-cc&Itemid=55

1017 28

Comments Off on #Mastery 28 – Reading and writing of files in C++

Posted in Blogs, Syndicated, TC1017 Blogs

Tagged , , , , , , , , , , , , ,

Mastery 28

Posted on 06/05/2015 by | Comments Off on Mastery 28

Reading and writing of files in C++

Opening a File:

A file must be opened before you can read from it or write to it. Either the ofstream or fstreamobject may be used to open a file for writing and ifstream object is used to open a file for reading purpose only.

Following is the standard syntax for open() function, which is a member of fstream, ifstream, and ofstream objects.

Here, the first argument specifies the name and location of the file to be opened and the second argument of the open() member function defines the mode in which the file should be opened.

Mode Flag Description
ios::app Append mode. All output to that file to be appended to the end.
ios::ate Open a file for output and move the read/write control to the end of the file.
ios::in Open a file for reading.
ios::out Open a file for writing.
ios::trunc If the file already exists, its contents will be truncated before opening the file.

You can combine two or more of these values by ORing them together. For example if you want to open a file in write mode and want to truncate it in case it already exists, following will be the syntax:

Similar way, you can open a file for reading and writing purpose as follows:

Closing a File

When a C++ program terminates it automatically closes flushes all the streams, release all the allocated memory and close all the opened files. But it is always a good practice that a programmer should close all the opened files before program termination.

Following is the standard syntax for close() function, which is a member of fstream, ifstream, and ofstream objects.

Writing to a File:

While doing C++ programming, you write information to a file from your program using the stream insertion operator (ofstream or fstream object instead of the cout object.

Reading from a File:

You read information from a file into your program using the stream extraction operator (>>) just as you use that operator to input information from the keyboard. The only difference is that you use an ifstream or fstream object instead of the cin object.

Read & Write Example:

Following is the C++ program which opens a file in reading and writing mode. After writing information inputted by the user to a file named afile.dat, the program reads information from the file and outputs it onto the screen:

When the above code is compiled and executed, it produces the following sample input and output:

Above examples make use of additional functions from cin object, like getline() function to read the line from outside and ignore() function to ignore the extra characters left by previous read statement.

Credits:

http://www.tutorialspoint.com/cplusplus/cpp_files_streams.htm

1017 28

Comments Off on Mastery 28

Posted in Blogs, Syndicated, TC1017 Blogs

Tagged , , , , , , , , , , , , , , , , ,

Mastery 27

Posted on 06/05/2015 by | Comments Off on Mastery 27

Validated user input in C++

For this mastery, I found  a super useful video that taught me how to make a validation for a user input

Here is also an example code with a validation user input code:

 

 
 

int main(){
    bool valid = false;
    int input;
    while(!valid){
        if(std::cin>>input){//this checks whether an integer was entered
            if(input  0) valid = true;//then we have to see if this integer is in range
        }else std::cin.clear();//some cleaning up
		
        std::cin.ignore(std::numeric_limits<:streamsize>::max(), 'n');//empty input stream

        if(!valid) std::cout "this input is not validn";
    }
    std::cout " is between 1 and 5n";
    std::cin.get();
    return 0;
}

 

Credits:

https://www.youtube.com/watch?v=YIX7UhIKEIk

1017 27

Comments Off on Mastery 27

Posted in Blogs, Syndicated, TC1017 Blogs

Tagged , , , , , , , , ,

Mastery 26

Posted on 06/05/2015 by | Comments Off on Mastery 26

Creation and use of matrixes in C++ (multi – dimensional arrays)

Two-Dimensional Arrays:

The simplest form of the multidimensional array is the two-dimensional array. A two-dimensional array is, in essence, a list of one-dimensional arrays. To declare a two-dimensional integer array of size x,y, you would write something as follows:

Where type can be any valid C++ data type and arrayName will be a valid C++ identifier.

A two-dimensional array can be think as a table, which will have x number of rows and y number of columns. A 2-dimensional array a, which contains three rows and four columns can be shown as below:

Mastery 26

Thus, every element in array a is identified by an element name of the form a[ i ][ j ], where a is the name of the array, and i and j are the subscripts that uniquely identify each element in a.

Initializing Two-Dimensional Arrays:

Multidimensioned arrays may be initialized by specifying bracketed values for each row. Following is an array with 3 rows and each row have 4 columns.

The nested braces, which indicate the intended row, are optional. The following initialization is equivalent to previous example:

Accessing Two-Dimensional Array Elements:

An element in 2-dimensional array is accessed by using the subscripts, i.e., row index and column index of the array. For example:

The above statement will take 4th element from the 3rd row of the array. You can verify it in the above digram.

When the above code is compiled and executed, it produces the following result:

As explained above, you can have arrays with any number of dimensions, although it is likely that most of the arrays you create will be of one or two dimensions.

Credits:

http://www.tutorialspoint.com/cplusplus/cpp_multi_dimensional_arrays.htm

1017 26

Comments Off on Mastery 26

Posted in Blogs, Syndicated, TC1017 Blogs

Tagged , , , , , , , , , , , , , , ,