diferencias sintácticas entre c y c++ · diferencias sintácticas entre c y c++ pablo san segundo...

Diferencias sintácticas entre C y C++

Pablo San Segundo (C-206) [email protected]

Extensión de ficheros fuente

Extensión de ficheros fuente en C: filename.c

Extensión de ficheros fuente en C++ filename.cpp

Linker

filename.cpp

filename.exe

Algunas palabras reservadas nuevas algebra booleana bool, true, false

espacios de nombres using, namespace, ::

clases, objetos class, public, private, protected, friend, virtual, this etc.

reserva de memoria new, delete

funciones inline, & (argumento referencia)

sobrecarga de operadores operator

excepciones catch, throw

Prioridad y asociatividad de operadores

Operador Asociatividad

::

( ) [ ] . -> v++ v-- typeid dynamic_cast

- + ! * & ++v --v sizeof new delete (tipo)

->* .*

* / %

+ -

<< >>

< <= > >=

== !=

&&

||

? :

= *= /= %= += -=

,

monarios

printf(“%d”,3-5-2);

printf(“%d”,3*5+2);

matemáticos

Declaraciones e inicializaciones

En C++ se pueden inicializar variables en cualquier momento, con visibilidad desde ese punto hasta el final del bloque.

void main(){ int a=0; //declaración tipo C for(int i=0; i<10; i++){ int sum=i; } int b=8; }

Operador ámbito (resolución de visibilidad)

:: : permite acceder a una variable global oculta por una variable local

int i=30; void main(){ for(int i=0; i<10; i++){ printf("%d",::i); } }

Espacios de nombres

namespace using namespace

int suma(int a, int b){ return a+b; } void main(){ printf("la suma es: %d\n",suma(3,5); }

namespace a309{ int suma(int a, int b){ return a+b; } } void main(){ printf("la suma es: %d\n",a309::suma(3,5)); }

namespace a309{ int suma(int a, int b){ return a+b; } } using namespace a309; void main(){ printf("la suma es: %d\n",suma(3,5); }

Comentarios

// printf("hola\n"); // printf("adios\n"); printf("hola y adios\n");

C++

C /* printf("hola\n"); printf("adios\n");*/ printf("hola y adios\n");

también /* …*/

Tipos de datos definidos por el usuario (1/2)

struct: simplificación de la sintaxis

struct foo_t{ int a; int b; }; void main(){ struct foo_t miFoo={1,3}; }

struct foo_t{ int a; int b; }; void main(){ foo_t miFoo={1,3}; }

C C++

Tipos de datos definidos por el usuario (2/2)

enum: En C++ es un tipo específico y no se permiten conversiones implícitas de tipo int como en C

enum enum_t {UNO=1, DOS, TRES, CUATRO}; void main(){ enum_t numero=(enum_t)1; //conversión obligatoria en C++ int dato=TRES; //permitido en C++ }

EJERCICIO I: Implemente un programa que asigne la tirada de un dado a un dato enum con los valores UNO…SEIS

#include <time.h> enum dado_t{UNO=1, DOS, TRES, CUATRO, CINCO, SEIS}; void main(){ srand(time(NULL)); int x= rand()%6+1; dado_t mydado= (dado_t)x; printf("%d", mydado); }

EJERCICIO II: Elija una pieza de ajedrez de manera aleatoria y muéstre la elección por pantalla

Modificaciones en funciones (1/5)

inline : Indica al compilador que incorpore el código de la función en cada llamada Se declara habitualmente en la definición de la función

inline int suma(int a, int b){ return a+b; }; void main(){ printf("suma: %d", suma(2,3)); }

#define SUMA(X,Y) ((X)+(Y)) void main(){ printf("suma: %d",SUMA(2,3)); }

EJERCICIO: Implemente una MACRO equivalente en C para la función suma

Mas sobre inlining Una función definida como inline tiene visibilidad de archivo

#include <stdio.h> #include "matematicas.h" int main(){ printf("%d\n", suma(3,4)); }

Archivo: matematicas.h

int suma(int a, int b);

Archivo: matematicas.cpp

inline int suma(int a, int b){ return 0; }


Sobrecarga de funciones: Diferenciación entre funciones por los tipos de sus argumentos, en tiempo de compilación Un valor de retorno distinto NO es suficiente

double suma(double a, double b){ puts("suma de numeros en coma flotante"); return a+b; }; int suma (int a, int b){ puts("suma de enteros"); return a+b; }; void main(){ printf("sumas: %d",suma(2,3)); //enteros printf("sumas: %f",suma(2.0,3.0)); //coma flotante }

CUESTIÓN: Sobrecargue la función suma con la suma de dos puntos 2D

Referencias

Una referencia puede verse como un nombre alternativo (o alias) para una variable. Sintaxis: operador ‘&’ como l-value

void main(){ int n=10; int &p = n; //inicialización obligatoria (p alias de n) //¡no puede ya ser un alias de otra variable! printf("%d %d\n",p, n); p=15; printf("%d %d\n",p, n); }

CUESTION ¿Se puede declarar una referencia constante?

void main(){ int n=10; const int &p = n; p=15; const int &k = 10; int &m = 10; }

CUESTION II Indique aquellas instrucciones no válidas


Uso de referencias como argumentos: Indica al compilador el paso por referencia. El argumento funciona como alias de la variable pasada con

visibilidad local

Paso de una referencia constante Argumentos son sólo de lectura Permite el paso de constantes como argumentos

void suma(double a, double b, double & res){ puts("suma de numeros en coma flotante"); res=a+b; }; void main(){ double r; suma(2.0, 3.0, r); printf("%f \n", r); }

void foo(const double& a);

CUESTIÓN: Implemente una función que simule la tirada de un dato y devuelva el valor por referencia. Compare la sintaxis con una función similar en C.


Uso de referencias como valor de retorno: Es incorrecto devolver una referencia a una variable/objeto

automático creado dentro la función Aplicación importante: sobrecarga de operadores

int& foo( int &a, int &b){ a+=b; return a; } void main(){ int a=3; int b=5; foo(a,b)+=25; printf("el valor de a es: %d", a); }

Ejercicio

int& foo( int &a, int &b){ a+=b; return a; } void main(){ int a=3; int b=5; foo(a,b)+25; printf("la suma es: %d\n",a); foo(a,b)+=25; printf("la suma es: %d\n",a); foo(a,b)+foo(a,b); printf("la suma es: %d\n",a); printf("la suma es: %d\n”, foo(a,b)+foo(a,b)); printf("la suma es: %d\n", foo(3,5)); }

a (pre) a (post) salida

8 8 8

8 38 38

38 48 48

48 58 116

Err Err Err

Indique la salida en pantalla del siguiente programa


Argumentos por omisión: se permiten en C++ siempre que sea en los argumentos finales Tienen que definirse obligatoriamente en la declaración de

la función

double suma(double a, double b = 5.0){ puts("suma de numeros en coma flotante"); return a+b; }; void main(){ printf("%f \n", suma(2.0)); }

Cuestiones ¿Son correctos los siguientes prototipos de funciones?

double foo(double a, double b = 5.0);

double foo(double a, double b = 5.0 , int c = 10);

double foo(double a, int b = 20 , int c = 10);

double foo(float a = 10, double b, double c = 5.0);

double foo(int a = 10, int b=5); void main(){ double res= foo(20); }

Sobrecarga de operadores

Es posible redefinir la funcionalidad de los operadores de tipo base para tipos de usuario

struct punto_t{ double x; double y; }; punto_t operator + (const punto_t& lhs, const punto_t& rhs){ punto_t pres; pres.x=lhs.x+rhs.x; pres.y=lhs.y+rhs.y; return pres; } void main(){ punto_t p1={1, 2}; punto_t p2={2, 4}; punto_t p3=p1+p2; printf("El punto es: [%.1lf,%.1lf]\n", p3.x, p3.y); }

Reserva dinámica de memoria

Palabras clave new y delete Equiparables a malloc y free en C REGLA: tantos delete como new

EJERCICIO: Implemente un programa que, para parámetros n y m 1. Reserve memoria para una matrix n x m (C++) 2. Inicialice sus valores a la matriz identidad 3. Imprima la matriz en pantalla 4. Libere la memoria adecuadamente antes de terminar (C++)

int* p = new int;

delete p;

int* array = new int[10];

delete [] array;

C++ Standard Library (STL)

ISO/IEC 14882:2003 C++ Standard Template Library (STL): colección de clases y

funciones que están ligadas al lenguaje y forman parte del ISO Espacio de nombres (std::) using namespace std;

#include <iostream> using namespace std; void main(){ cout<<“hola mundo”<<endl; //equivale a std::cout<<… }

Cadenas de caracteres- std::string (1/3)

std::string de C++ es el equivalente a la cadena en C Es la clase más popular de la STL

string str = "Hello World!"; cout << str << endl; printf("%c\n", str[0]);

#include <string>

string str("Hello Universe!"); string start = str.substr(0, 5); string end = str.substr(6); cout<<start<<endl; cout<<end<<endl;

string str("How long is this string?"); cout << "Length of string is: " << str.size() << endl; cout << "Length of string is: " << str.length() << endl;

string str("Hello, can you find Ben?"); size_t pos = str.find("Ben", 15, 2); if(pos!=string::npos){ cout << "First occurrence of Ben was found at: " << pos << endl; }

Cadenas de caracteres- std::string (2/3) #include <string>

string str = "C++ is an impressive language."; size_t pos = str.find_first_of(" ."); while (pos != string::npos) { cout << "Found space or dot at: " << pos << endl; pos = str.find_first_of(" .", pos + 1); }

string str = "C++ is an impressive language"; size_t pos = str.find_first_of("aeiou"); while (pos != std::string::npos) { str[pos]='*'; pos = str.find_first_of("aeiou", pos + 1); } cout<<str<<endl;

CUESTIÓN ¿Cómo cree el alumno que se interpreta la instrucción str[pos]='*'?

Cadenas de caracteres- std::string (3/3) #include <string>

CUESTIÓN Extraiga el nombre del fichero (brock200_1.clq) del path completo de la cadena a continuación: "/home/pss/graphs/brock200_1.clq"

CUESTIÓN Escriba la función que reciba un nombre de un path como string y añada un slash (/) o backslash (\) al final del mismo dependiendo del sistema operativo (LINUX ó Win) Ejemplos: “ home/pss/graphs” “home/pss/graphs/ " “c:\pss\graphs” “c:\pss\graphs\”

CUESTIÓN Compruebe el efecto de los operadores sobrecargados asignación (=), suma (+) y acceso ([ ]) para la clase string

Flujos (entrada / salida)

Flujo: objeto lógico que representa el canal de comunicación

Flujos en C++ (se crean automáticamente) cin: flujo de entrada estándar (por defecto teclado) cout: flujo de salida estándar (por defecto pantalla) cerr y clog: flujos de errores y mensajería (por def. pantalla)

#include <iostream> (NO <iostream.h>) Sobrecarga de operadores >> y << Predefinido para tipos de datos base

Cada dato sabe la cadena de caracteres que lo representa

Sobrecargables para los tipos de datos de usuario

operadores texto

Ejemplo: manejo de flujos con tipos base

#include <iostream> using namespace std; void main(){ cout<<"Introduzca tres sumandos separados por un espacio:\n"<<endl; int a, b, c; if(cin>>a>>b>>c){ cout<<"la suma es:"<<a+b+c<<endl; } }

EJERCICIO: Modifique el programa visto anteriormente y relativo a la inicialización de una matriz: 1. Gestione la salida a pantalla mediante el flujo cout 2. Gestione la entrada por teclado de las dimensiones de la

matriz mediante el flujo cin

Detalle-lectura controlada por pantalla struct dim_t{ int n; int m; }; dim_t get_dim(){ dim_t key_dim; do{ cin.clear(); /* limpia el estado */ cout<<"Introduzca dos numeros por teclado"<<endl; cin>>key_dim.n>>key_dim.m; fflush(stdin); /* limpia la entrada de teclado*/ }while(!cin); /* sobrecarga el operador ! */ return key_dim; } void main(){ dim_t dim; dim=get_dim(); cout<<"Las dimensiones son "<<dim.n<<" x "<<dim.m<<endl; }

Equivalencias de flujos con C (1/2)

Salida a pantalla stdout-printf #include <stdio.h> cout #include <iostream>

Entrada por teclado stdin-scanf #include <stdio.h> cin #include <iostream>

Salida a fichero fprintf #include <stdio.h> [o]fstream #include <fstream>

Entrada desde fichero fscanf #include <stdio.h> [i]fstream #include <fstream>

Equivalencias de flujos con C (2/2)

Salida a cadena de caracteres en memoria con formato sprintf #include <stdio.h> [o]stringstream #include <sstream>

Entrada desde cadena de caracteres en memoria con formato sscanf #include <stdio.h> [i]stringstream #include <sstream>

Ejemplos con flujos (1/3) #include <stdio.h> int main(void){ FILE * pFile; pFile = fopen ("file.txt","w");

/* … */ fclose (pFile); return 0; }

#include <iostream> #include <fstream> using namespace std; int main(void){ ofstream f("file.txt", ofstream::out);

/* … */ f.close(); return 0; }

#include <stdio.h> int main (){ char cadena [100]; sprintf(cadena, "Soy %s", "juan"); printf("%s\n", cadena); }

#include <iostream> #include <string> #include <sstream> using namespace std; int main (){ stringstream sstr; string cadena="juan"; sstr<<"Soy "<<cadena; cout<<sstr.str(); }

Ejemplos con flujos (2/3) #define NUM_NAMES 3 #include <stdio.h> int main(void){ FILE * pFile; int n; char name [100]; pFile = fopen ("myCfile.txt","w"); for (n=0 ; n<NUM_NAMES ; n++){ puts ("please, enter a name: "); gets (name); fprintf (pFile, "Name %d [%s]\n",n+1,name); } fclose (pFile); return 0; }

#define NUM_NAMES 3 #include <iostream> #include <fstream> using namespace std; int main(void){ char name [100]; ofstream f("myC++file.txt", ofstream::out); for (int n=0 ; n<NUM_NAMES ; n++){ cout<<"please, enter a name: "<<endl; cin>>name; f<<"Name "<<n+1<<" ["<<name<<"]"<<endl; } f.close(); return 0; }

CUESTION ¿Comprobación que el fichero se ha abierto correctamente?

Ejemplos con flujos (3/3) #define NUM_NAMES 3 #include <stdio.h> int main(void){ int n; char name [100]; char formatted_name [100]; for (n=0 ; n<NUM_NAMES ; n++){ puts ("please, enter a name: "); gets (name); sprintf(formatted_name, "Name %d [%s]\n",n+1,name); puts(formatted_name); } return 0; }

#define NUM_NAMES 3 #include <iostream> #include <sstream> using namespace std; int main(void){ char name [100]; ostringstream oss(""); for (int n=0 ; n<NUM_NAMES ; n++){ cout<<"please, enter a name: "<<endl; cin>>name; oss<<"Name "<<n+1<<" ["<<name<<"]"<<endl; cout<<oss.str(); oss.str(""); oss.clear(); } return 0; }

Ejercicio

Un alumno tiene asociado los siguientes datos en una asignatura: Nombre del alumno Nombre de la asignatura Número de matricula Número de grupo

Se pide: Contruir una cadena de caracteres en memoria de la forma:

Log a fichero de texto “log.txt” de esta información.

nombre: Mario Pedraza asignatura: Informatica Industrial matricula_id: 50788 grupo_id: 3

Ejercicio (1/2)

Un alumno tiene asociado los siguientes datos en una asignatura: Nombre del alumno Nombre de la asignatura Número de matricula Número de grupo

Se pide: Contruir una cadena de caracteres en memoria de la forma:

Log a fichero de texto “log.txt” de esta información.

nombre: Mario Pedraza asignatura: Informatica Industrial matricula_id: 50788 grupo_id: 3

Ejercicio-estructuración (2/2)

stringstream& format_string(datos_t& d, stringstream& o)

void print_string(string str) void read_data_from_keyboard(datos_t& d) void to_file(string filename, string str)

struct datos_t{ char nombre [100]; char course [100]; int id; int id_group; };

CUESTION ¿Prototipo para una función que convierta a texto(ASCII) el struct datos_t?

Conversión explícita (forzada)

static_cast <tipo_nuevo> (dato) Convierte el dato al tipo nuevo si posible

void main(){ cout<<'A'<<endl; cout<<static_cast<int>('A')<<endl; //conversión explícita cout<<5.70<<endl; cout<<static_cast<int>(5.70)<<endl; //conversión explícita }

void main(){ int a =5.03; //conversión implícita }

dynamic_cast <tipo_nuevo> (dato)

Paso de argumentos desde la línea de comandos

int main (int argc, char** argv) argc : número de argumentos pasados en línea de comandos

incluyendo el nombre del ejecutable argv : tabla de argumentos pasados

argv[0] es el nombre del binario

EJERCICIO Implemente un programa que reciba como argumento el nombre del fichero (“log.txt”) del ejercicio anterior y muestre la ficha del alumno en pantalla. Nota: Muestre un mensaje de error en caso de que falte el dato del fichero en la llamada al ejecutable.

Diferencias C vs. C++

I. Palabras clave II. Sobrecarga de funciones III. Sobrecarga de operadores IV. Referencias V. Flujos VI. Paso de parámetros a un

ejecutable

¿PREGUNTAS?

diferencias sintácticas entre c y c++ · diferencias sintácticas entre c y c++ pablo san segundo...

Documents