Resolucion Examen Final

Resolucion Examen Final Video!!


ing ahi esta el video en camtasia del parcial explicando paso por paso la resolucion , para poder sustentar con esto la nota de la segunda practica

#include <iostream>
#include <stdlib.h>

using namespace std;
int x;

void enunciado1 ()
{
    cout<<"ingrese el valor de x, siempre y cuando x es negativo"<<endl;
    cin>>x;
         while (x>0);
         {
             x= x-3;
             cout<<x<<"\n";
                
                 }
     }

void enunciado2 ()
{
     cout<<"ingrese el valor de x, siempre y cuando x es positivo"<<endl;
     cin>>x;
    
       while (x<0);
         {
                 x= x-3;
                 cout<<x<<"\n";
                
                 }
     }
    
    
void enunciado3 ()
{
     x=10;
     do
     {
                cout<<x<<"\n";
                x= x-3;
                } while(x>0);
     }
    
void enunciado4 ()
{
     x=-42;
     do
     {
                cout<<x<<"\n";
                x= x-3;
                } while(x>0);
                    
     }
    
void enunciado5 ()
{
     cout<<"ingrese el valor de x, siempre y cuando x es negativo"<<endl;
     cin>>x;
     while(x>0);
     {
               x= x+3;
               cout<<x<<"\n";
              
               }
    
     }
    
void enunciado6()
{
     cout<<"ingrese el valor de x"<<endl;;
     cin>>x;
     if(x<0)
     {
            cout<<x*(-1)<<" es el valor positivo"<<endl;
            }
     else
     {
         cout<<x*(-1)<<" es el valor negativo"<<endl;
         }
    
     }
    
void enunciado7 ()
{
     cout<<"este programa permite la conversion de metros a pies y a centimetro"<<endl;
     double distancia_metros, distancia_cm, distancia_ft;
     int repetir_o_no;
     repetir_o_no = 1;
     while (repetir_o_no == 1)
    {
     cout<< "Dame una cantidad en metros \n";
     cin>> distancia_metros;
     distancia_cm = distancia_metros * 100;
     distancia_ft = distancia_metros * 3.048;
     cout<<"\n";
     cout<<"Su equivalente en centimetros es "<<distancia_cm<<" \n";
     cout<<"Su equivalente en pies es "<<distancia_ft<<" \n";
     cout<<"\n";
     cout<<"Deseas realizar otro calculo similar? \n";
     cout<<"Escribe el numero 1 si lo deseas, si no, \n";
     cout<<"escribe cualquier otro numero entero \n";
     cin>>repetir_o_no;
     cout<<"\n";
      }
}
    
    
    
int main()
{
    char opcion;
    cout<<"A) Enunciado 1 \nB) Enunciado 2 \nC) Enunciado 3 \nD) Enunciado 4 \nE) Enunciado 5\nF) Enunciado 6\nG) Enunciado 7\n";
    cout<<"Seleccione la accion que desea ejecutar"<<endl;
    cin>>opcion;
   
    switch (opcion)
    {
           case 'a':
                enunciado1 ();
                break;
           case 'b':
                enunciado2 ();
                break;
           case 'c':
                enunciado3 ();
                break;
           case 'd':
                enunciado4 ();
                break;
           case 'e':
                enunciado5 ();
                break;
           case 'f':
                enunciado6();
                break;
           case 'g':
                enunciado7 ();
                break;
           default :cout<<"usted ha digitado incorrectamente"<<endl;
           }
    system("PAUSE");
    return 0;
}

Viedotutorial Algoritmo Ordenamiento Punteros

Video en camtasia: el video se muestra la implementación del algoritmo presentado anteriormente.

A continuación se muestra el código:

#include <iostream>
#include <iomanip>

using namespace std;

 void orden(int*, const int);// prototipo
 void swap(int * const, int * const);// prototipo

int main()
{
    const int nSize =10;

    int a[ nSize ]={3, 9, 14, 27, 18, 154, 8, 6, 74, 33};  //numeros a ordenar

    cout<<"\nElementos a ordenar\n";

    for(int j =0; j < nSize; j++)
    cout<< setw(5)<< a[ j ];
    cout<< endl;

    orden( a, nSize );// funcion que ordena el arreglo, definida en la parte inferior

    cout<<"\nElementos ordenados\n";

    for(int j =0; j < nSize; j++)
    cout<< setw(5)<< a[ j ];
    cout<< endl;

    return 0;// indica terminación exitosa

}
int aux;
 void orden(int*matriz, const int nSize )
{
    for(int pasada =0; pasada < nSize -1; pasada++)
    {
        for(int k =0; k < nSize -1; k++)
        {
            if( matriz[ k ]> matriz[ k +1])
            {  swap(&matriz[ k ], &matriz[ k +1]);
                }

        }
        aux = pasada + 1;
        cout<< setw(5)<< aux<<" ";
        for(int l =0; l < nSize; l++)  cout<< setw(5)<<matriz[ l ];
        cout<< endl;
    }
}

void swap(int*const ptrElemento1, int*const ptrElemento2 )
{
    int mantiene =*ptrElemento1;
    *ptrElemento1 =*ptrElemento2;
    *ptrElemento2 = mantiene;
}

Programación en C++/Estructura "video tutorial"

Busncando y recopilando videos encontramos algo que llama la atension en este video. Es el mas interesante

Programación en C++/ Punteros "videos tutorial"

Programacion C++ - Punteros 1/6

 

Programacion C++ - Punteros 2/6

 

 Programacion C++ - Punteros 3/6

Programacion C++ - Punteros 4/6

 Programacion C++ - Punteros 5/6

Programacion C++ - Punteros 6/6

Programación en C++/ Estructura I.."· Estructuras compuestas (struct, union, class) "

Estructuras compuestas (struct, union, class)

Con base en los tipos básicos mostrados arriba, se pueden crear nuevos tipos con estructuras compuestas por uno o más de uno de los tipos mencionados. En C, C++ en orden de crear nuevas estructuras se emplean la palabras reservadas struct, union y class.

-struct: esta orden se emplea para agrupar variables de tipos iguales o diferentes en un solo registro, con la misma se pueden crear estructuras anónimas, estructuras con nombre, y un tipo especial de estructura conocida como bit-fields ( banderas o campos de bits ).

-union: una union es similar a una struct, salvo que en una estructura creada con union los campos o variables comparten una dirección de almacenamiento común.

-class: una clase es una estructura en donde se agrupan variables y funciones, la misma es usada en Programación Orientada al Objeto. Las clases no son soportadas por el C estándar.

Sintaxis general: struct

struct[<nombre tipo de estructura >]{

[<tipo><nombre-variable[, nombre-variable, ...]>];

[<tipo><nombre-variable[, nombre-variable, ...]>];

    ...

}[<variables de estructura>];

Nota: recuerde que lo que se muestra entre corchetes es opcional.

struct: Sintaxis ( variación uno, estructura anónima )

De acuerdo con la sintaxis general de la orden struct es posible crear estructuras de datos anónimas. Solamente hay que tener en cuenta que en una declaración anónima se debe definir al menos una variable al final de la declaración. Por ejemplo, con el siguiente fragmento de código:

struct{int a, b;} p1;

se declara y define la variable estructurada p1, misma que se compone por los miembros a y b; ambos del tipo int. Ahora bien, la sintaxis mostrada arriba no es tan común ni conveniente, ya que con la misma solamente se esta creando una variable estructurada pero no un nuevo tipo. Es decir, si desearamos tener otra variable que tuviera las mismas caracteristicas que posee la variable p1, necesitariamos escribir exactamente la misma instrucción, salvo que cambiando el nombre de la variable. Por ejemplo:

struct{int a, b;} p2;

Por supuesto, en una misma línea de instrucción podemos definir más de una variable. Ejemplo:

struct{int a, b;} p1, p2;

Entonces, para crear nuevos tipos con struct deberemos de modificar la sintaxis mostrada en los ejemplos anteriores.

Sintaxis: struct ( variación dos, estructura con nombre )

Observe que, la sintaxis para declarar estructuras con nombre es bastante parecida a la sintaxis para declarar estructuras anónimas; salvo que una declaración de estructura con nombre se debe especificar el nombre deseado para la misma. Además, en una declaración de estructura con nombre la o las variables definidas al final de la misma son opcionales.

Ejemplos:

struct pareja {int a, b;} p1;

En el fragmento de código anterior se declara la estructura identificada como pareja, misma que se compone de los miembros a y b, ambos de tipo int. En el mismo ejemplo, se define la variable p1; la cual es una variable estructurada de tipo pareja.

Una vez que una estructura con nombre ha sido creada, la misma puede ser usada para declarar cualquier número de variables. Por ejemplo, en el siguiente fragmento de código se crea la estructura tiempo compuesta por los miembros hora, minuto y segundo; todos del tipo int. En el mismo ejemplo, se declaran las variables t1 y t2.

/* declaración de estructura tiempo */

struct tiempo {int hora, minuto, segundo;};

/* declaración de variables de tipo tiempo */

struct tiempo t1, t2;

Nota: en C++ puede obviarse la palabra struct a la hora de declarar variables. Así, en C++ la línea de instrución struct tiempo t1, t2; ( del ejemplo anterior) puede escibirse como: tiempo t1, t2;

Acceso a los miembros de una estructura

En orden de poder leer o escribir uno de los miembros de una variable estructurada se debe usar el operador de acceso ( . ), o sea, el nombre de la variable seguida por un punto seguido por el nombre del miembro o componente deseado de la estructura. Por ejemplo, para acceder a los miembros de la variable t1 (mostrada arriba) podemos hacerlo de la siguiente manera:

t1.hora=12;

t1.minuto=0;

t1.segundo=0;

printf("%i\n", t1.hora);

cout<< t1.minutos<< endl;

Estructuras anidadas

Los miembros de una estructura pueden ser ellos mismos otra estructura previamente identificada o bien una estructura anónima. Por ejemplo, en el siguiente fragmento de código se crean las estructuras pareja y pareja2. Observese cómo dentro de los miembros de pareja2 se declara el miembro X, mismo que es una estructura del tipo pareja. Luego, las variables declaradas a raiz de la estructura pareja2 poseerán los miembros variables a y b heredados de pareja, y c.

struct pareja {int a, b ;};

struct pareja2 {struct pareja X;int c;} P3;

Ahora bien, para acceder a los miembros de una estructura dentro de otra estructura se emplea el mismo mecanismo de acceso (el punto). Por ejemplo, para desplegar el miembro a de la variable P3 declarada en el ejemplo anterior, lo haremos más o menos así:

printf("%i\n", P3.X.a);

Herencia

El termino herencia se usa con gran frecuencia en Programación Orientada al Objeto, y se le relaciona principalmente con las clases. Sin embargo, la herencia está presente siempre y cuando una estructura "struct", "union" o "class" posea a otra estructura.  En ese sentido, en C++ se presentan dos tipos de herencia:

§  herencia por agregación o composición.

§  herencia por extensión.

Por ejemplo, en la definicion de las estructuras pareja y pareja2 del ejemplo anterior, se dice que pareja2 hereda por composición todos los miembros de pareja. Ahora, en el siguiente ejemplo se usa la sintaxis para que la estructura pareja2 herede por extensión los miembros de pareja:

// solo C++

struct pareja {int a, b ;};

struct pareja2 : pareja {int c;} P3;

Estructura de campos de bits

Un campo de bit es un elemento de una estructura definido en terminos de bits. Usando un tipo especial de definicion de struct, se pueden declarar elementos de estructura con rangos de 1 a 16 de largo. (dependiendo de la arquitectura de la PC y del compilador, el rango para una estructura de campos de bits puede ser de 1 a 16, 1 a 32, 1 a 64). Antes de ver un ejemplo del uso de struct para crear estructuras de campos de bits consideremos el caso en donde se tiene una variable del tipo short (16 bits) y que para la misma se desea que los bits tengan significados especificos. digamos que el primer bit servirá para controlar alguna condición; los siguientes cuatro bits, o sea del segundo al quinto bit, controlarán otra condición; el bit 6 tendrá otra funcion; y el resto, o sea del septimo al decimosexto bit se emplearán  1 o un 0 podemos emplear la siguiente sintaxis:

int  X =123;

int  r = X &1;

la cosa parece sencilla, pero ahora consideremos el caso en el cual deseamos saber cual es el valor contenido por el grupo de bits ( segundo al quinto ), entonces nos daremos cuenta que no basta con una prueba mediante AND ( X & 1 ) sino que hay que  que realizar otros pasos.

Precisamente, para problemas como el planteado arriba es que el lenguaje C,C++ da soporte a las estructuras de campos de bits. . Por ejemplo, la estructura.

struct  campo_de_bit {

int bit_1        :1;

int bits_2_a_5   :4;

int bit_6        :1;

int bits_7_a_16  :10;

} bit_var;

 corresponde a la siguiente colección de campos bits:  

Nota: tanto las estructuras como las uniones y las clases pueden ser anónimas, pero lo más

recomendable es darle a las mismas un nombre. Si una estructura, union o clase posee

nombre, esta pueden ser empleadas para declarar variables de la misma y, lo más importante,

puede ser usada para el paso de parámetros a funciones.