TEORIA DE PUNTEROS

OBJETIVO: Aprender y Entender la teoría de punteros en c , ya que es un tema muy importante en la programación , que debemos dominarlo , para poder resolver problemas sobre este tema , es importante y la vez entretenido , este tema es muy extenso y existen varias formas de aprender y de resolver

TEORIA DE PUNTEROS

CONCEPTO: Un puntero o apuntador es una variable que contiene una dirección de memoria. En esa posición de memoria se encuentra almacenada una variable de un tipo determinado (entera, real o carácter). Su tamaño es de 4 bytes.
Se dice que la primera variable (el puntero) apunta a la segunda.
Un puntero también puede apuntar a otro puntero, es decir, almacenar la dirección de memoria de otro puntero.
DECLARACIÓN:

Para que un puntero pueda apuntar a una variable debe ser declarado de la siguiente manera:
tipo*identificador
donde tipo es el tipo de variable a la que apunta (si es variable entera, int; si es real, float o double; y si es un carácter, char), * indica que es un puntero, e identificador es el nombre del puntero.
Los punteros sólo pueden apuntar a variables del mismo tipo que ellos.
(A partir de ahora llamaremos p, q... a identificadores de punteros en general, que deberemos inicializar para poder usarlos).
Si queremos que un puntero q apunte a otro p se declara así:
tipo* *q

OPERADORES:

Los operadores que se usan con los punteros son &, *, y el operador asignación =.

-En C, al contrario que en otros lenguajes de programación, se puede obtener directamente la dirección de memoria de cualquier variable sobre la que opera el puntero. Esto es posible hacerlo con el operador referencia & de la siguiente forma:
p=&x
donde x es la variable a la que apunta el puntero.

-Para acceder a la variable a la que apunta el puntero se utiliza el operador desreferencia * de esta forma:
x=*p 
donde x es la variable que obtiene un nuevo valor (el valor de la variable a la que apunta el puntero).
Si un puntero q apunta a otro p, se utiliza dos veces el operador *.

ARITMÉTICA DE PUNTEROS:

-Suma/resta de punteros:
Sólo puede hacerse suma y resta de un puntero con un entero. Esta operación avanza o retrasa el puntero tantas veces como indica el entero con el que se opera. Se procede así:
p=p+n 
donde n es un entero. (Por ejemplo, si n=1, el puntero p avanza 4 bytes).

-Comparación de punteros:
Se pueden comparar punteros, es decir, comparar las relativas posiciones de memoria:
Si tenemos que p>q, significa que p apunta a una dirección de memoria mayor que q.
Si tenemos que p<q, significa que p apunta a una dirección de memoria menor que q.

ERRORES COMUNES CON PUNTEROS:

-Asignar punteros de distinto tipo (un float con un char, un int con un double...).
Por ejemplo:
int a=1 ;
int *p ;
double b=2.0 ;
double *q ;
p=&a ;
q=&x ;
q=p; ERROR 

-Usar punteros no inicializados.
Por ejemplo:
char *p;
*p='a';
(FALTARÍA PONER: char c;
p=&c; )

-Asignar valores al puntero en vez de a la variable:
Por ejemplo:
int x;
int *p;
p=&x;
p=7; MAL (DEBERÍA SER *p=7)

-Hacer asignaciones a la dirección de memoria NULL (dirección de memoria cero).
Por ejemplo:
int *p=NULL;
*p=6; // ERROR (NO SE PUEDE ASIGNAR NADA A LA DIRECCIÓN DE MEMORIA NULL)
RELACIÓN ENTRE PUNTEROS Y VECTORES:

Un vector es un conjunto de variables del mismo tipo que se referencian con un mismo nombre y con un índice.
En C, los punteros y los vectores están fuertemente relacionados, hasta el punto de que el nombre de un vector es un puntero al primer elemento del vector. Para ir avanzando sobre el vector, cuyos elementos están situados en memoria consecutivamente, basta ir moviendo el puntero con simples incrementos sobre el vector. Así pues, siendo v el nombre de un vector en general, tenemos que:
v[i] es equivalente a *(v+i) 
(Ej: v[4]=v[3]+7 es equivalente a *(v+4)=*(v+3)+7)
&v[i] es equivalente a (v+i) 
(Ej: &v[2] es equivalente a (v+2))
Por tanto, todas las operaciones que utilizan vectores e índices pueden realizarse mediante punteros.
Sin embargo, hay que tener cuidado a la hora de no rebasar los límites del trozo de memoria donde se almacena el vector.

RELACIÓN ENTRE PUNTEROS Y MATRICES:

Una matriz es un conjunto de variables del mismo tipo que se referencian con un mismo nombre y con dos índices.
Al igual que con vectores, en C, al declarar una matriz, se crea un puntero con el mismo nombre que la matriz. También se puede avanzar en la matriz y realizar operaciones de idéntica forma que con los vectores.
Siendo m una matriz en general, m[DIM1][DIM2], tenemos que:
m[i] es equivalente a &m[i][0] 
(Ej: m[7]=&m[7][0])
m[i][j] es equivalente a *(m[i]+j) y es equivalente a *(m[0]+i*DIM2+j)
(Ej: m[2][3]=20 es equivalente a *(m[2]+3) y es equivalente a *(m[0]+2*DIM2+3)
(m+i) es equivalente a &m[i]
(Ej: (m+4) es equivalente a &m[4])
m[i][j] es equivalente a *(*m+i*DIM2+j) 
(Ej: m[5][6] es equivalente a *(*m+5*DIM2+6))
EJEMPLOS DE COLA Y PILA

Ejemplo: Pila basada en un arreglo estático

#include <iostream>
using namespace std;
 
#define STACK_SIZE 256 /* capacidad máxima */
typedef char arreglo[STACK_SIZE];
 
class Stack {
  
 int sp; /* puntero de lectura/escritura */
 int items; /* número de elementos en lista */
 int itemsize; /* tamaño del elemento */
 arreglo pila;  /* el arreglo */
  
 public:
  // constructor
  Stack() {
   sp = STACK_SIZE-1;
   items = 0;
   itemsize = 1;
   }
  
  // destructor
  ~Stack() {};
  
 /* regresa el número de elementos en lista */
 int size() { return items; }
  
 /* regresa 1 si no hay elementos en la lista, o sea, si la lista está vacia */
 int empty() { return items == 0; }
  
 /* insertar elemento a la lista */
 int put(char d)
 {
  if ( sp >= 0) {
   pila[sp] = d;
   sp --;
   items ++;
  }
  return d;
 }
  
 /* retirar elemento de la lista */
 int get()
 {
  if ( ! empty() ) {
   sp ++;
   items --;
  }
  return pila[sp];
 }
  
}; // fin de clase Stack
 
 
// probando la pila. 
// Nota: obseve cómo los elementos se ingresan en orden desde la A hasta la Z,
// y como los mismos se recuperán en orden inverso.
int main()
{
    int d;
    Stack s;  // s es un objeto (instancia) de la clase Stack
 
    // llenando la pila
    for (d='A'; d<='Z'; d++) s.put(d);
 
    cout << "Items =" << s.size() << endl;
 
    // vaciando la pila
    while ( s.size() ) cout << (char)s.get() << " ";
 
    cout << "\nPara terminar oprima <Enter>...";
    cin.get();
    return 0;
}
}

Ejemplo: Pila basada en un arreglo dinámico

/*---------------------------------------------------------------+
+ ejemplo de una pila ( STACK ) enlazada dinámicamente +
+ +
+ Autor: Oscar E. Palacios +
+ email: oscarpalacios1@yahoo.com.mx +
+ +
+ Manifiesto: +
+ Este programa puede distribuirse, copiarse y modificarse de +
+ forma libre. +
+---------------------------------------------------------------*/
#include <iostream>
//#include <conio.h>

using namespace std;

/* tipo de dato que contendrá la lista */
typedef char DATA_TYPE;

// declaraci¢n de estructura nodo
struct nodo {
 DATA_TYPE data;
 nodo *next;
};

class StackDin {

    // atributos
    int ITEMS;    /* número de elementos en la lista */
    int ITEMSIZE; /* tamaño de cada elemento */
    nodo *SP;     /* puntero de lectura/escritura */

public:
    // constructor
    StackDin() : SP(NULL), ITEMS(0), ITEMSIZE(sizeof(DATA_TYPE)) {}

    // destructor
    ~StackDin() {}

    /* agregar componente a la lista */
    DATA_TYPE put(DATA_TYPE valor)
    {
 nodo *temp;

 temp = new nodo;
 if (temp == NULL) return -1;

 temp->data = valor;
 temp->next = SP;
 SP = temp;
 ITEMS ++;
 return valor;
    }

    int empty() { return ITEMS == 0; }


    /* retirar elemento de la lista */
    DATA_TYPE get()
    {
 nodo *temp;
 DATA_TYPE d;

 if ( empty() ) return -1;

 d = SP->data;
 temp = SP->next;
 if (SP) delete SP;
 SP = temp;
 ITEMS --;
 return d;
    }

}; // fin de la clase StackDin


/* punto de prueba para la clase StackDin */
int main()
{
    //clrscr();

    StackDin s;
    DATA_TYPE d;

    for (d='A'; d<='Z'; d++) s.put(d);

    while ( ! s.empty() )
 cout << (DATA_TYPE)s.get() << " ";

    cout << "\nPara terminar presione <Enter>...";
    cin.get();
    return 0;
}COLA
cola
  |
+---+---+---+---+---+
|   |   |   |   |   |    al principio
+---+---+---+---+---+
  |
  cabeza

      cola
      |
+---+---+---+---+---+    put('A');
| A |   |   |   |   |    después de haber agregado el primer elemento
+---+---+---+---+---+
  |
  cabeza


...
                  cola
                  |
+---+---+---+---+---+
| A | B | C | D |   |    después de haber agregado cuatro elementos
+---+---+---+---+---+
  |
  cabeza


Vaciando la cola.
  cabeza
  |
+---+---+---+---+---+
| A | B | C | D |   |    antes de haber retirado elementos
+---+---+---+---+---+

      cabeza
      |
+---+---+---+---+---+    get();
| A | B | C | D |   |    después de haber retirado un elemento
+---+---+---+---+---+


...
                  cabeza
                  |
+---+---+---+---+---+    al final
| A | B | C | D |   |    después de haber retirado todos los elementos
+---+---+---+---+---+
                  |
                  cola

CONCLUSION:

Este tema de punteros me pude dar cuenta que es muy útil e importante para aprender a programar muy fácilmente, debemos saber como resolver ya que este tema es muy complejo , y un poco difícil de entender , si fallas una linesa programación no te puede salir

BIBLIOGRAFÍA:

http://www.mailxmail.com/curso-introduccion-lenguaje-c/punteros
www.uhu.es/04004/material/Transparencias6.pdf

VIDEO :https://www.youtube.com/watch?v=OgX4vdtkkHQ

Primer programa de Estructuras
EXPLICACION:
Este  programa hace la misma funcion del otro pero lo unico que cambia son los valores de los tipos de datos CHAR y cambia la forma de programar
#include <string.h> #include <stdio.h> #include <stdlib.h> #include <iostream> using namespace std; struct datos{ char nom[50]; int edad; int cedula; char estado[50]; char sexo[10]; char nacionalidad[50]; }; datos dato_1; main() { cout<<"ingrese su nombre\n"; cin>>dato_1.nombre; cout<<"ingrese su edad\n"; cin>>dato_1.edad; cout<<"ingrese su cedula\n"; cin>>dato_1.cedula; cout<<"ingrese su estado\n"; cin>>dato_1.estado; cout<<"ingrese su sexo\n"; cin>>dato_1.sexo; cout<<"ingrese su nacionalidad\n"; cin>>dato_1.nacionalidad; system("cls"); cout<<"\n su nombre es : "<<dato_1.nombre; cout<<"\n su edad es: "<<dato_1.edad; cout<<"\n su cedula es: "<<dato_1.cedula; cout<<"\n su estado es : "<<dato_1.estado; cout<<"\n su sexo es : "<<dato_1.sexo; cout<<"\n su nacionalidad es : "<<dato_1.nacionalidad; getch();

PROGRAMA EN C , CON ESTRUCTURA
EXPLICACIÓN:
Este programa realiza la siguiente funcion :
Va a imprimir tus datos personales en forma de estructura y se va hacer mas facil entender sobre este tema con este programa porque es el mas sencillo y facilmente de entender
PROGRAMA
include <string.h> #include <stdio.h> #include <stdlib.h> #include <iostream> using namespace std; struct datos{ char nom[50] int edad; int cedula; char estado[50]; char sexo[10]; char nacionalidad[50]; }; datos dato_1; main() { cout<<"ingrese su nombre\n"; cin>>dato_1.nombre; cout<<"ingrese su edad\n"; cin>>dato_1.edad; cout<<"ingrese su cedula\n"; cin>>dato_1.cedula; cout<<"ingrese su estado\n"; cin>>dato_1.estado; cout<<"ingrese su sexo\n"; cin>>dato_1.sexo; cout<<"ingrese su nacionalidad\n"; cin>>dato_1.nacionalidad; system("cls"); cout<<"\n su nombre es : "<<dato_1.nombre; cout<<"\n su edad es: "<<dato_1.edad; cout<<"\n su cedula es: "<<dato_1.cedula; cout<<"\n su estado es : "<<dato_1.estado; cout<<"\n su sexo es : "<<dato_1.sexo; cout<<"\n su nacionalidad es : "<<dato_1.nacionalidad; getch(); }
https://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Estructuras_y_Uniones

UNIDAD EDUCATIVA FISCOMISIONAL"DON BOSCO"

NOMBRE: BRYAN NARVAEZ

CURSO: 2 DO INFORMATIKA

1) QUE SON ESTRUCTURAS DINAMICAS ??

Son aquellas en las que el tamaño ocupado en memoria se define antes de que el programa se ejecute y no puede modificarse dicho tamaño durante la ejecución del programa.

SINTAXIS y EJEMPLOS

Algoritmo 1

DOBLE LECTURA

{Este algoritmo resuelve el problema planteado en el ejemplo 1, por medio de una doble lectura}

{I y CONT son variables de tipo entero. AC, PROM y C son variables de tipo real}

1. hacer AC = 0 e I = 1
   Leer calificación I (C)
   Hacer AC = AC + C e I = I+1
2. Repetir mientras (I<= 50)
3. {Fin del ciclo del paso 2}
   {Como se necesita decir cuántos alumnos obtuvieron una calificación superior al promedio, se deberá volver a leer las 50 calificaciones para poder comparar cada una de ellas con el promedio}
   Hacer CONT = 0 e I = 1
4. Hacer PROM = AC / 50
   Leer calificación I (C)
   1. Si C> PROM entonces
   Hacer I = I + 1
5. Repetir mientras (I<=50)
6. {Fin del ciclo del paso 5}
7. Escribir CONT

Algoritmo 2.

 MUCHAS VARIABLES

{Este algoritmo resuelve el problema planteado en el ejemplo 1, utilizando múltiples variables}

{I y CONT son variables de tipo entero. AC, PROM y C son variables de tipo real}

1. {Las calificaciones correspondientes a los 50 alumnos}
   Hacer AC = C1 + C2 + C3 + .....+C50
   PROM = AC / 50 y CONT = 0
2. Leer C1, C2, C3,....C50
   Hacer CONT = CONT + 1
3. Si C1 > PROM entonces
4. {Fin del condicional del paso 2}
5. Si C2> PROM entonces
6. {Fin del condicional del paso 4}

...

100. Hacer CONT = CONT + 1
101. Si C50 > PROM entonces
102. {Fin del condicional del paso 100}
103. Escribir CONT

En la solución planteada en el algoritmo 1, el usuario del algoritmo

#include <stdio.h>
main()
{int cuenta, q;
int *m;
cuenta=100;
m=&cuenta; //m recibe la dirección de cuenta
q=*m; //a q se le asigna el valor de cuenta
indirectamente a través de m
print("%d,q") //imprime 100
}

Punteros estáticos
Definamos un puntero a un entero y una variable entera como sigue:
Int *p1;
Int valor1;
Con estas definiciones es posible hacer las siguientes asignaciones estáticas:
p1= *valor1;
*p1=25

Leer más: http://www.monografias.com/trabajos14/estrucdinamicas/estrucdinamicas.shtml#ixzz3sHDbSTPu

PARA MAS INFORMACION DEL TEMA ABRE EL LINK Y VERAS QUE ENTIENDES MAS SOBRE AQUELLO
Link de video : 4https://www.youtube.com/watch?v=K1V0LzvM_34

Diferencias y caracteristicas entre c y c++

UNIDAD EDUCATIVA FISCOMISIONAL " DON BOSCO"

NOMBRE: BRYAN NARVAEZ 

CURSO: 2DO INFORMATICA

TEMA: DIFERENCIAS Y CARACTERISTICAS ENTRA C Y C++

OBJ: RECONOCER Y DIFERENCIAR LAS CARACTERISTICAS DE CADA UNO DE LOS TERMINOS DE PROGRAMACION YA QUE EN LA VIDA DIARIA LA PODEMOS APLICAR .

 DIFERENCIAS ENTRE C Y C++

 -Prototipo en C: char f1(void); 

 -Prototipo en C++: char f1(); 

 -Aunque C++ es un superconjunto de C, existen algunas diferencias entre los dos. En primer lugar, en C cuando una función no toma parametros, su prototipo tiene la palabra void. sin embargo en C++ void no es necesario(opcional). 

-En C

1 2 3 4 5 6 7

#include<stdio.h>   int main() { printf ("Hola Mundo"); return 0; }

En C++

1 2 3 4 5 6 7 8 9

#include<iostream>   using namespace std;   int main() { cout << "Hola mundo"; return 0; }

-En 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

#include<iostream> using namespace std;   int main() { int radio; float area, perimetro;   // SALIDA: mensaje un pantalla cout << "Introduce el radio del circulo: ";   //ENTRADA: recibir dato desde teclado cin >> radio;   // calculos area = 3.1416 * radio * radio; perimetro = 3.1416 * radio * 2;   //SALIDA: resultado en pantalla cout << "El area es " << area << " y el perimetro " << perimetro; cin.get();cin.get();   return 0; } -Pedir un dato en C scanf("modificador", &nombre de la variable); Pedir un dato en C++ cin >> nombre de la variable; -Mostrar un dato en C++ cout << "Dato: " << nombre de la variable; Los modificadores son los siguientes: %d para int, %f para float, %s para string, %c para char.

Librerías en C++

Por simple convención las librerías en C terminan en ‘.h’ (punto hache). Todas las librerías de C sirven para C++, sin embargo, también por convención, se elimina la terminación ‘.h’ y mejor se agrega ‘c’ al principio.

Libreria en C      Librería en C++

math.h                  cmath

string.h                 cstring

time.h                   ctime

etcetera.

-C fue creado en 1972 por Dennis M. Ritchie en los Laboratorios Bell como evolución del anterior lenguaje B, a su vez basado en BCPL.

C++, por su parte, fue creado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que permitan la manipulación de objetos.

CARACTERISTICAS DE C

Es un lenguaje de medio nivel, pero ¿qué significa esto?. Los lenguajes de alto nivel se asemejan a nuestra forma de razonar, aislando al programador de los detalles técnicos (referentes a la máquina física). Esto hace que este tipo de lenguajes sean poco eficientes. Por el contrario, los lenguajes debajo nivel controlan directamente la circuitería del ordenador, pudiendo obtenerse con ellos la eficiencia máxima (sin embargo, resultan incómodos y poco portables). Así las ventajas de los lenguajes de alto nivel respecto a los de bajo nivel son :

Sencillez.

Uniformidad.

Portabilidad.

CARACTERISTICAS C++

C++ es un lenguaje de programación diseñado a mediados de los años 80 por Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que permitieran 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 sumó a los otros dos paradigmas que ya estaban admitidos (programación estructurada y la programación orientada a objetos). Por esto se suele decir que el C++ es un lenguaje de programación multiparadigma. 

Este video te puede explicar mejor :

?v=LmOvlpqD_g0

ESTE VIDEO TE PUEDO EXPLICAR MAS SOBRE EL TEMA , SI QUIERES MEJOR APRENDIZAJE ABRE EL LINK

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