Diferencias sintácticas entre C y C++ Pablo San Segundo (C-206)

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.cppfilename.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 OperadorAsociatividad :: ( ) [ ]. -> 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 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: Coloque una pieza de ajedrez de manera aleatoria en la esquina inferior derecha de un tablero de ajedrez

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  Una función declarada inline tiene visibilidad de archivo 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

Modificaciones en funciones (2/5)  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));//doble precisión } EJERCICIO: 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  Aplicación: paso por referencia de argumentos a una función void main(){ int n=10; int &p = n;//inicialización del alias printf("%d %d\n",p, n); p=15; printf("%d %d\n",p, n); } CUESTIÓNES ¿Se puede declarar una referencia constante? ¿Qué comportamiento tiene una referencia constante?

Modificaciones en funciones (3/5)  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); EJERCICIO: 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.

Modificaciones en funciones (4/5)  Uso de referencias como valor de retorno:  El retorno de una referencia tiene aplicación directa en la sobrecarga de operadores  Es incorrecto devolver una referencia a una variable/objeto automático creado dentro la función 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”, 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 Err Indique la salida en pantalla del siguiente programa

Modificaciones en funciones (5/5)  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); }

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: 1. Pregunte al usuario por las dimensiones de una matriz (n, m) 2. Reserve memoria 3. Inicialice sus valores a 0 4. Imprima la matriz en pantalla 5. Libere la memoria adecuadamente antes de terminar int* p = new int; delete p; int* vector = new int[10]; delete [] vector;

C++ Standard Library (STL)  ISO/IEC 14882:2003  C++ Standard Library: 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 using namespace std; void main(){ cout<<“hola mundo”<<endl;//equivale a std::cout<<… }

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 (NO )  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 using namespace std; void main(){ cout<<"Introduzca tres sumandos separados por un espacio"<<endl; int a, b, c; cin>>a>>b>>c; cout<<"la suma es:"<<a+b+c<<endl; } EJERCICIO: Modifique el programa anterior relativo a la inicialización de una matriz a 0 para que: 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

Equivalencias de flujos con C (1/2)  Salida a pantalla  stdout-printf #include  cout: #include  Entrada por teclado  stdin-scanf: #include  cin: #include  Salida a fichero  fprintf#include  [o]fstream#include  Entrada desde fichero  fscanf#include  [i]fstream#include

Equivalencias de flujos con C (2/2)  Salida a cadena de caracteres en memoria con formato  sprintf#include  [o]stringstream#include  Entrada desde cadena de caracteres en memoria con formato  sscanf #include  [i]stringstream #include

Ejemploscon flujos (1/2) #define NUM_NAMES3 #include 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_NAMES3 #include 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; }

Ejemploscon flujos (2/2) #define NUM_NAMES 3 #include 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 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: grupo: 3

Conversión explícita (forzada)  static_cast (dato)  Convierte el dato al tipo nuevo si posible void main(){ cout<<'A'<<endl; cout ('A')<<endl; //conversión explícita cout<<5.70<<endl; cout (5.70)<<endl; //conversión explícita } void main(){ int a =5.03; //conversión implícita }  dynamic_cast (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 argumentos un nombre (string) y un identificador (entero) y muestre en pantalla ambos. Nota: Muestre un mensaje de error en caso de que falten algunos de los dos datos.