Anuncios Google

Introducción a C++ desde C

Tutoriales de Programaciones

Bienvenidos a un nuevo cursillo creado por mí, P22, en el que aprenderéis a programar en C++ sabiendo C (que podéis aprender aquí). La sintaxis de C y C++ es muy similar, pero debes tener en cuenta que C++ es un lenguaje orientado a objetos (POO de ahora en adelante, de Programación Orientada a Objetos). En estos tutoriales aprenderás en que consiste la POO y como implementarla con C++.

Características principales

C++ Fue diseñado por Bjarne Stroustrup en los años 80. Su intención fue convertir el lenguaje C en uno que estuviera orientado a objetos. Por tanto, C++ es el resultado de una mejora de C, convirtiéndose en un lenguaje multiparadigma: Orientado a Objetos e imperativo (este último es el de C). Cabe destacar que cualquier programa de C que se compile con un compilador de C++ como si fuera un programa de este, funcionará perfectamente (excluyendo las funciones de las librerías nativas).

Fuente

POO ¿Qué es?

Como ya se ha dicho, POO son las siglas de Programación orientada a objetos. Este paradigma nos ofrece una visión diferente de los programas: Creamos una clase, que podríamos definir como una estructura con unas características especiales, y a partir de ahí la usamos para crear otros objetos, que constituye todo lo físico (y no tan físico) que tengamos a nuestro alrededor.

class ordenador{
 
   private:
      float velocidad_cpu;
      float velocidad_gpu;
      char* mbmodelo;
      int potencia_fuente;
 
   public:
      ordenador();
      void change_vel_cpu();
      ~ordenador();
}

Ese sería más o menos la definición básica (y si, he dicho básica, aunque poco más puede llevar) de una clase en C++. Esto de momento no lo voy a explicar.

A lo largo de estos tutoriales iremos viendo las diferencias entre C++ y C, creando, como hemos hecho con C, una serie de tutoriales con ejemplos.

De momento, me limito a deciros que para usar funciones de entrada/salida de datos, la librería no es stdio.h, sino iostream.

Para terminar con este primer tutorial:

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

#include <iostream>

Se incluye la librería de iostream, que es la que incluye las funciones de entrada y salida de datos.

using namespace std;

Esto se podría explicar así:

//Si no usamos lo anterior, habrá que escribir:
std::cout << "Hola Mundo!" << endl;
 
//Si lo usamos:
cout << "Hola Mundo!" << endl;

int main(){

Esto deberíamos saberlo ya... No obstante, es la función principal. No varía respecto a C.

cout << "Hola Mundo!" << endl;

Es equivalente a printf. Los símbolos '<<' separan los diferentes componentes de la función. endl es similar a \n (caracter de nueva línea). Por si no se entiende lo de que separa los elementos:

int var = 0;
...
cout << "var vale: " << var << endl;
 
V Correcto
 
----------------------
int var = 0;
...
cout << "var vale: " var endl;
 
X Error

Y esto es todo por ahora, en el próximo tutorial, más y mejor (que ya es difícil :P)

4.354165
Tu voto: Ninguno Votos totales: 4.4 (48 votos)

Anuncios Google

Comentarios

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de JRizzoA

Que buen tuto, espero que

Que buen tuto, espero que sigas con el. llevo mucho tiempo queriendo aprender C++

Imagen de pipagerardo

Clases con sobrecarga de operadores.

Este es un ejemplo de clase que maneja el color en OpenGL, tiene constructores y sobrecarga de operadores, espero que os sirva de ejemplo...


//-------------------
//-- PGL_Color.h --
//-------------------
#ifndef _PGL_Color_
#define _PGL_Color_
#include <GL/gl.h>  
 
       
class PGL_Color {
  public:
        
// -----------------------
// -- Constructores:  --
// -----------------------
    PGL_Color();
    PGL_Color( GLubyte _rojo, GLubyte _verde, GLubyte _azul, GLubyte _transparencia = 255 );
    PGL_Color( const PGL_Color &copia );
   
// -------------------
// -- Destructor:  --
// -------------------
    ~PGL_Color();

// -----------------------------------
// -- Asignaciones de Valores:  --
// -----------------------------------
    void rojo( GLubyte _rojo );
    void verde( GLubyte _verde );
    void azul( GLubyte _azul );
    void alpha( GLubyte _alpha );
    void rgba( GLubyte _rojo, GLubyte _verde, GLubyte _azul, GLubyte _transparencia = 255 );

// ------------------------------
// -- Retornos de Valores:  --
// ------------------------------
    GLubyte rojo() const;
    GLubyte verde() const;
    GLubyte azul() const;
    GLubyte alpha() const;
    bool    alpha_b() const;
    GLubyte *rgba() const;

// ---------------------
// -- Operaciones:  --
// ---------------------
    PGL_Color& operator=( const PGL_Color &copia ); // -- Asigna un color a otro.
    bool operator==( const PGL_Color &copia );      // -- Retorna true si son iguales.
    PGL_Color operator+( const PGL_Color &copia );  // -- Suma dos colores.
    void operator++();       // -- Preincremento,  if ( color > 255 ) color = 255;
    void operator++( int );  // -- Postincremento, if ( color > 255 ) color = 0;
    void operator--();       // -- Decremento,     if ( color <   0 ) color = 0;
    void operator--( int );  // -- Posdecremento,  if ( color <   0 ) color = 255;

  private:
    GLubyte *color;      
    bool alpha_bool;
   
};

#endif


//----------------------
//-- PGL_Color.cpp --
//----------------------
#include "PGL_Color.h"

// ------------------------
// -- Constructores:   --
// ------------------------
PGL_Color::PGL_Color() {
      color = new GLubyte[4];
      color[0] = 0; color[1] = 0; color[2] = 0; color[3] = 255; alpha_bool = false;
}
PGL_Color::PGL_Color( GLubyte _rojo, GLubyte _verde, GLubyte _azul, GLubyte _alpha ) {
      color = new GLubyte[4];
      color[0] = _rojo; color[1] = _verde; color[2] = _azul; color[3] = _alpha;
      if ( color[3] < 255 ) alpha_bool = true;
      else                       alpha_bool = false;
}
PGL_Color::PGL_Color( const PGL_Color &copia ) {
      color = new GLubyte[4];
      color[0]   = copia.color[0];
      color[1]   = copia.color[1];
      color[2]   = copia.color[2];
      color[3]   = copia.color[3];
      alpha_bool = copia.alpha_bool;
}
         
// --------------------
// -- Destructor:   --
// --------------------
PGL_Color::~PGL_Color() { delete[] color; }

// --------------------------------
// -- Asignación de Valores:  --
// --------------------------------
void PGL_Color::rojo( GLubyte _rojo )   { color[0] = _rojo;  }
void PGL_Color::verde( GLubyte _verde ) { color[1] = _verde; }
void PGL_Color::azul( GLubyte _azul )   { color[2] = _azul;  }
void PGL_Color::alpha( GLubyte _alpha ) {
       color[3] = _alpha;
       if ( color[3] < 255 ) alpha_bool = true;
       else                      alpha_bool = false;
}
void PGL_Color::rgba( GLubyte _rojo, GLubyte _verde, GLubyte _azul, GLubyte _alpha ) {
       color[0] = _rojo; color[1] = _verde; color[2] = _azul; color[3] = _alpha;
       if ( color[3] < 255 ) alpha_bool = true;
       else                       alpha_bool = false;
}
    
// ----------------------------
// -- Retorno de Valores: --
// ----------------------------
GLubyte  PGL_Color::rojo()  const  { return color[0];   }
GLubyte  PGL_Color::verde() const  { return color[1];   }
GLubyte  PGL_Color::azul()  const  { return color[2];   }
GLubyte  PGL_Color::alpha() const  { return color[3];   }
bool     PGL_Color::alpha_b() const { return alpha_bool; }
GLubyte* PGL_Color::rgba() const   { return color;      }

// ----------------------
// -- Operaciones:  --
// ----------------------
PGL_Color& PGL_Color::operator=( const PGL_Color &copia ) {
      color[0] = copia.color[0];
      color[1] = copia.color[1];
      color[2] = copia.color[2];
      color[3] = copia.color[3];
      alpha_bool = copia.alpha_bool;
}
bool PGL_Color::operator==( const PGL_Color &copia ) {
      if ( ( color[0] == copia.color[0] ) &&
           ( color[1] == copia.color[1] ) &&
           ( color[2] == copia.color[2] ) &&
           ( color[3] == copia.color[3] ) ) return true;
      return false;
}
PGL_Color PGL_Color::operator+( const PGL_Color &copia ) {
      PGL_Color tmp;
      tmp.color[0] = ( color[0] + copia.color[0] ) >> 1;
      tmp.color[1] = ( color[1] + copia.color[1] ) >> 1;
      tmp.color[2] = ( color[2] + copia.color[2] ) >> 1;
      tmp.color[3] = ( color[3] + copia.color[3] ) >> 1;
      if ( tmp.color[3] < 255 ) tmp.alpha_bool = true;
      else                              tmp.alpha_bool = false;
      return tmp;
}
void PGL_Color::operator++() {
      if ( color[0] < 255 ) ++color[0];
      if ( color[1] < 255 ) ++color[1];
      if ( color[2] < 255 ) ++color[2];
}
void PGL_Color::operator++( int ) {
      if ( color[0] < 255 ) ++color[0]; else color[0] = 0;
      if ( color[1] < 255 ) ++color[1]; else color[1] = 0;
      if ( color[2] < 255 ) ++color[2]; else color[2] = 0;
}
void PGL_Color::operator--() {
      if ( color[0] > 0 ) --color[0];
      if ( color[1] > 0 ) --color[1];
      if ( color[2] > 0 ) --color[2];
}
void PGL_Color::operator--( int ) {
      if ( color[0] > 0 ) --color[0]; else color[0] = 255;
      if ( color[1] > 0 ) --color[1]; else color[1] = 255;
      if ( color[2] > 0 ) --color[2]; else color[2] = 255;
}

Imagen de pspgorrister

Antes de nada felicitarte por

Antes de nada felicitarte por el tutorial, y luego aunque se me clasifiquen de quisquilloso, quería decir que los "<<" no son separadores de la función cout, primero porque cout/cin/cerr no son funciones, y luego "<<" lo mismo que "=", ">=", son operadores.

El hacer posible el uso de cout con "<<" (o cin con ">>"), viene de una cosa muy importante que C no tiene: La sobrecarga de operadores. La cual no tiene absolutamente nada que ver con funciones y parámetros, es más intenta evitar eso mismo, el uso de funciones y parámetros.

No pretendo hacer mala crítica de tu tutorial, sólo quería remarcar un aspecto importante, principalmente porque este tutorial supuestamente pretende diferenciar C de C++, y la sobrecarga de operadores es concepto muy importante de C++.

Un saludo y esperamos más tutoriales.


LuaDiE: Crea en Lua sin teclear código. Compatible HM7, HMv2, LuaPlayer, LuaDEV y PGE.

Imagen de P22

¿?

No lo entiendo :P Te refieres a esto? http://es.wikipedia.org/wiki/Sobrecarga

Imagen de the dragon lives

Los simbolos

Los simbolos: <<, >>, <<=, >>= y otros cuantos son operadores a nivel de bit.

En cuanto a la sobrecarga de operadores, aqui algo de info.

Imagen de pspgorrister

Sí, aunque ahí sólo habla de

Sí, aunque ahí sólo habla de la sobrecarga de métodos no de operadores. Es complejo para explicarlo en un Post.

Imagen de razieliyo

Siempre me había preguntado

Siempre me había preguntado el por qué de los operadores << y >> en cout, cin y cerr, no sabía que se trataba de una sobrecarga de operadores. Supongo que cin, cout y cerr serán algo así como objetos direccionados a la salida y entrada estándar, no?

Voy a intentar explicar la sobrecarga de operadores por ti, muy simplificadamente, por si a alguien le interesa. Se usa para poder utilizar operadores (+,-,/,%,...) con objetos. Lo que hace es definir el uso de dichos operadores para una determinada clase. Un ejemplo bastante común podría ser una clase llamada Quebrado, que si tenemos dos objetos de dicha clase llamados q1 y q2, si a C++ le dices q1 + q2, te daría error, pues C++ no sabe sumar objetos, a menos que le enseñes. Ahí es donde entra en juego la sobrecarga de la que habla pspgorrister.

El concepto creo que está claro, pero su uso, como dice gorri, es bastante complicado para un post. De todas formas, al que le interese indagar, siempre estará C++ con clase, o este tutorial cuando avance un poco más =)

Saludos!

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.