PDF de programación - Seminario de C++ - Sesión 1

Imágen de pdf Seminario de C++ - Sesión 1

Seminario de C++ - Sesión 1gráfica de visualizaciones

Publicado el 30 de Agosto del 2017
485 visualizaciones desde el 30 de Agosto del 2017
209,9 KB
10 paginas
Creado hace 16a (28/10/2004)
Algoritmos y Estructuras de Datos

Ingeniería en Informática, Curso 2º, Año 2004/2005

SEMINARIO DE C++

Sesión 1



Contenidos:

1. Características generales de C++
2. Entrada/salida estándar
3. Variables y tipos de datos
4. Funciones
5. Memoria dinámica
Ejercicios



Algoritmos y Estructuras de Datos, 2004/2005
Seminario de C++ – Sesión 1

2/10

1. Características generales de C++



• C++ es un superconjunto de C → Cualquier programa C (o casi cualquiera) es

también un programa C++.


• C++ es una extensión de C para incluir programación orientada a objetos, así

como otras mejoras menores de C.


• ¿Dónde está colocado C++ en el mundo de los lenguajes de programación?

Lenguajes

imperativos puros

Lenguajes
híbridos

Lenguajes orientados a

objetos puros

C

Pascal

Módula-2

Basic

C++

ObjectPascal

Delphi

Smalltalk

Java
Eiffel

• Pero, ¿en qué consiste la programación orientada a objetos?
• Idea sencilla: una clase es como un tipo registro que incluye datos y funciones.

Un objeto es una variable de ese tipo.

En C

struct pila {
int tope;
int datos[MAX_CAPACIDAD];
};

void vaciar (pila *p);
void push (pila *p, int v);
void pop (pila *p);
int top (pila *p);

struct pila p;
vaciar(p);
push(p, 16);
push(p, 12);
pop(p);

En C++

class pila {
private:
int tope;
int datos[MAX_CAPACIDAD];
public:
void vaciar (void);
void push (int v);
void pop (void);
int top (void);
};
pila p;
p.vaciar();
p.push(16);
p.push(12);
p.pop();

• Naturaleza dual de las clases:

tipos definidos por el usuario).

o Una clase es un tipo abstracto de datos (mecanismo para crear nuevos
o Una clase es un módulo que proporciona encapsulación (agrupa
funciones y datos relacionados) y ocultamiento de la implementación
(parte private y parte public).







Algoritmos y Estructuras de Datos, 2004/2005
Seminario de C++ – Sesión 1

3/10

• Modificaciones menores de C++ respecto a C.


o Extensión de los ficheros de código: .cpp (también .cc, .C, .Cpp ...)

o Extensión de los ficheros de cabecera: .hpp (o sin extensión)
o Compilación: c++ (o g++)
o Comentarios en una sola línea: // Comentario

/* Esto es un comentario de C
que se puede extender varias líneas */

// Y esto es un comentario de C++
// que se extiende hasta fin de línea

2. Entrada/salida estándar

• Igual que en C, y también...

• La librería iostream añade un nuevo estilo para la lectura y escritura en

entrada y salida estándar.
Variables:

Operadores:

o cin . Flujo de entrada estándar.
o cout. Flujo de salida estándar.
o cerr. Flujo de error estándar.
o cin >> variable. Leer un valor de teclado y escribir en variable.
o cout << expresion. Escribir la expresión en la salida estándar.
o cerr << expresion. Igual, con la salida de error estándar.



#include <iostream> // Ojo: notar que va sin .h

int main ()
{
int numero= 1; // Esta inicialización es irrelevante
char nombre[80];
cout << "¿Como te llamas? ";
cin >> nombre;
cout << "Hola " << nombre << '\n'; // Se pueden poner varios <<
cout << "Un número: ";
cin >> numero;
cout << "El C++ es " << numero << " veces mejor que el C.\n";
/* Añadir por aquí */
}


o cin.getline(char *res, int max). Leer una línea de teclado,
hasta '\n' o hasta completar max-1 caracteres. (Esta forma es mejor
con char *, porque el cin >> cadena se puede desbordar.)

Algoritmos y Estructuras de Datos, 2004/2005
Seminario de C++ – Sesión 1

4/10

3. Variables y tipos de datos



• A diferencia de C, existe un tipo de datos booleano: bool, con los valores true
y false. También los operadores and, or, not y xor (ojo, en algunas
versiones no están definidos).
/* Añadir por aquí */

bool pequeno= numero<4, grande= numero>3;
if (grande && ! pequeno) //Probar:(grande and not pequeno)
cout << "Estoy de acuerdo.\n";
else
cout << "Muy mal!!\n";

• Se pueden declarar variables en cualquier punto del código.



int main (void) {
printf("Esto está en C.\n ");
int i= 3;
cout << "i vale: " << i;
for (int k= 0; k<100; k++) {
int p;
cout << k << '\a';
}
}



• Declaración de constantes: modificador const. El compilador impide las

asignaciones sobre variables de tipo const. Deben inicializarse siempre.
const double pi= 3.1415926;
const int edad= 99;
const char letra; // ERROR, debe inicializarse
edad++; // ERROR, edad es una constante

o En general, se recomienda usar constantes const en lugar de #define.
o Constantes de tipo puntero.

const char *nombre= "Pepito"; → El valor apuntado es constante

aunque el puntero sí puede cambiar.

char * const nombre= "Pepito"; → El puntero no puede cambiar

aunque el contenido sí puede.

const char *const nombre= "Pepito"; → El puntero no puede cambiar

y el contenido tampoco.

o Parámetros constantes en funciones.
char * strcpy (char * destino, const char *origen)

→ La función no va a cambiar el contenido de la cadena origen



• Los nombres de las estructuras y las uniones son tipos de datos.

struct persona {...}; En C: struct persona p1; En C++: persona p1;

Algoritmos y Estructuras de Datos, 2004/2005
Seminario de C++ – Sesión 1

5/10

• Casting con notación funcional.

double a;
a= (double) 4; // Esto es C (o C++)
a= double(4); // Esto es C++

• Operador de resolución de visibilidad ‘::’. Un mismo nombre de variable
puede aparecer en distintos ámbitos (por ejemplo, variable global y local a una
función). Este operador permite acceder a la variable global desde la función.
double a= 1.0;
main ()
{
int a= 4;
::a= 3.0; // Acceso a la variable global
a= 7; // Acceso a la variable local
}


• Espacios de nombres. En lugar de declarar todos los datos y funciones como

globales, es posible definir espacios de nombres.
#include <string> // Contiene la clase string, alternativa
// a los (char *) de C
namespace GGM
{
int edad;
string nombre= "Gines";
}
main ()
{
cin >> GGM::edad; // Se debe añadir el prefijo GGM::
cout << GGM::nombre << ' ' << GGM::edad;
}

• using namespace. Usar un espacio si necesidad del prefijo GGM:: ...


using namespace GGM;
main ()
{
cout << nombre << ' ' << edad;
}

• Ojo. En algunas implementaciones cout, cin y cerr están definidos en el



espacio de nombres std .

o Tenemos que poner std::cout, std::cin, std::cerr
o O bien...

#include <iostream>
using namespace std;
int main ()
{
cout << "El using namespace puede ser necesario.\n";
int valor;
cin >> valor;
}

Algoritmos y Estructuras de Datos, 2004/2005
Seminario de C++ – Sesión 1

6/10



4. Funciones

Igual que en C.



• Principales novedades: paso de parámetros por referencia, parámetros por

defecto y sobrecarga de funciones.

• Paso de parámetros por referencia: (..., tipo & nombre, ...)

void suma (int a, int b, int &c)
{
c= a + b;
}

• También es posible declarar variables de tipo referencia. Sólo se puede asignar



un valor en la declaración. No se usa el operador *.
int i= 1;
int &r= i; // r referencia al mismo sitio que i
r++;
i++;
cout << r;


• Parámetros por defecto: si no aparece un parámetro en la llamada, tomar un

valor por defecto.



tipoDevuelto nombreFuncion (tipo1 nombre1, tipo2 nombre2, ...,



tipon-1 nombren-1= valorn-1, tipon nombren= valorn)
o Los parámetros por defecto deben ser los últimos en la lista de parámetros de
o En la llamada se pueden poner algunos y otros no. Se rellenan siempre de

la función.

izquierda a derecha.
#include <iostream>
using namespace std;

void defectuosa (int a, int b, int c= 1, int d= 2, int e= 6)
{
cout<<a<<' '<<b<<' '<<c<<' '<<d<<' '<<e<<'\n';
}

int main(void)
{
defectuosa(10, 20);
defectuosa(10, 20, 30);
defectuosa(10, 20, 30, 40);
defectuosa(10, 20, 30, 40, 50);
}



Algoritmos y Estructuras de Datos, 2004/2005
Seminario de C++ – Sesión 1



• Sobrecarga de funciones. Dos, o más, funciones distintas pueden tener el

7/10

mismo nombre. Es posible si los tipos de los parámetros son distintos.
#include <iostream>
using namespace std;

#include <stdlib.h>

void saludar (void)
{
cout << "Bienvenido, señor desconocido.";
}

void saludar (char *nombre)
{
cout << "¡Hola " << nombre << "!";
}

void saludar (int n)
{
cout << "Te saludo " << n << " veces.";
}

int main (int narg, char *cad[])
{
if (narg==1)
saludar();
else if (atoi(cad[1]))
saludar(atoi(cad[1]));
else
saludar(cad[1]);
}



Algoritmos y Estructuras de Datos, 2004/2005
Seminario de C++ – Sesión 1

8/10

5. Memoria dinámica

• Igual que en C, aunque también una forma nueva... y mejor...

• Operadores: new, new[], delete y delete[].
• Operador: new tipo. Crea una nueva variable de tipo tipo. Devuelve un



puntero a la variable creada.
int *p1= new int;

struct persona {....};
persona *p2= new persona;


• Operador: new tipo[tamaño]. Crea un array dinámico de tipo tipo y de
tamaño elementos (el primero será el 0). Devuelve un puntero al inicio del array
creado.
o No hace falta indicar el tamaño del tipo de datos. El número de
o No se inicializa la memoria.
o Si falla provoca una excepción.
o Mejor que malloc y calloc.

elementos del array
  • Links de descarga
http://lwp-l.com/pdf6667

Comentarios de: Seminario de C++ - Sesión 1 (0)


No hay comentarios
 

Comentar...

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios...
CerrarCerrar
CerrarCerrar
Cerrar

Tienes que ser un usuario registrado para poder insertar imágenes, archivos y/o videos.

Puedes registrarte o validarte desde aquí.

Codigo
Negrita
Subrayado
Tachado
Cursiva
Insertar enlace
Imagen externa
Emoticon
Tabular
Centrar
Titulo
Linea
Disminuir
Aumentar
Vista preliminar
sonreir
dientes
lengua
guiño
enfadado
confundido
llorar
avergonzado
sorprendido
triste
sol
estrella
jarra
camara
taza de cafe
email
beso
bombilla
amor
mal
bien
Es necesario revisar y aceptar las políticas de privacidad