Introducción a C++

Samsung Research Tijuana

Tipos fundamentales

Enteros

Tipo Tamaño mínimo
bool 1 byte
char 1 byte
short 2 bytes
int 4 bytes
long 8 bytes
long long 8 bytes

Flotantes

Tipo Precisión Tamaño mínimo
float 7 dígitos 4 bytes
double 15 dígitos 8 bytes
long double 15 dígitos 8 bytes

Caracteres

Tipo Tamaño minimo Codificación
char 1 byte UTF-8
wchar_t 2 bytes -
char16_t 2 bytes UTF-16
char32_t 4 bytes UTF-32

Tipos compuestos

Referencias

#include <iostream>

void printI(const int &i)
{
    std::cout << "i = " << i << std::endl;
}

void incI(int &i) { ++i; }

int main()
{
    int i = 0;
    int &err;          /* Error: Una referencia siempre debe ser inicializada */
    int &ri1 = i;      /* ri1 es una referencia a i */
    int &ri2 = ri1;    /* ri2 es una referencia a i */

    incI(i);
    printI(i);         /* i = 1 */

    incI(ri1);
    printI(ri1);       /* i = 2 */
    printI(i);         /* i = 2 */

    incI(ri2);
    printI(ri2);       /* i = 3 */
    printI(i);         /* i = 3 */

    incI(6);           /* Error: No se puede crear una referencia a un objeto temporal, */
    printI(6);         /*        a menos que se trate de una referencia constante.      */
    return 0;
}

Apuntadores

#include <iostream>

void printI(const int *i) { std::cout << "i = " << *i << std::endl; }

void incI(int *i) { ++(*i); }

int main()
{
    int i = 0;
    int *uptr;         /* Apuntador no inicializado */
    int *pi1 = &i;     /* pi1 es un apuntador a i */
    int *pi2 = pi1;    /* pi2 es un apuntador a i */

    printI(uptr);      /* Error: Acceso invalido de memoria. */

    incI(i);           /* Error: i no es de tipo apuntador */
    incI(&i);          /* &i regresa un apuntador a la direccion de i */
    printI(&i);        /* i = 1 */

    incI(pi1);
    printI(pi1);       /* i = 2 */
    printI(&i);        /* i = 2 */

    incI(pi2);
    printI(pi2);       /* i = 3 */
    printI(&i);        /* i = 3 */

    incI(6);           /* Error: No se puede crear un apuntador a un objeto temporal, */
    printI(6);
    return 0;
}

Literales

/* Booleanos */
auto si = true;       /* bool */
auto no = false;      /* bool */

/* Caracteres */
auto u8 = 'a';       /* char */
auto u16 = u'a';     /* char16_t (Unicode 16) */
auto u32 = U'a';     /* char32_t (Unicode 32) */
auto wc = L'a';      /* wchar_t */
auto u8s = u8"Hola"; /* Cadena con codificación UTF-8 */ 

/* Enteros */
auto dec = 20;       /* int con valor decimal de 20 */
auto oct = 024;      /* int con valor octal de 24 (decimal 20) */
auto hex = 0x14;     /* int con valor hexadecimal de 14 (decimal 20) */
auto x = 20u;        /* unsigned int */
auto y = 20l;        /* long */
auto z = 20ll;       /* long long */

/* Flotantes */
auto d = 20.0;       /* double */
auto f = 20.0f;      /* float */
auto ld = 20.0l;     /* long double */

/* Apuntadores */
int *x = nullptr;    /* nullptr indica que un apuntador es nulo. */

Clases

class ISerializable
{
    protected:
        virtual char[] serialize() = 0;
        virtual char[] deserialize() = 0;
};

class DatabaseModel
{
    protected:
        DatabaseModel();

        DatabaseConnection mDatabase;
};
#include <string>

class Speaker 
    : public DatabaseModel, public ISerializable
{
    public:
        /* Constructor */
        Speaker() 
            : DatabaseModel(), /* Constructor clase base */
              mId(0), mModel(""), mBrand("")  {}

        unsigned int id() { return mId; }
        std::string model() { return mModel; }
        std::string brand() { return mBrand; }

        void setId(unsigned int id) { mId = id; }
        void setModel(std::string model) { mModel = model; }
        void setBrand(std::string brand) { mBrand = brand; }

        void saveChanges() { mDatabase.save(this); }

    private:
        unsigned int id mId;
        std::string mModel;
        std::string mBrand;

    protected:
        char[] serialize() { /* Codigo de serializacion */ }
        char[] deserialize() { /* Codigo de deserializacion */ }
};

Calificadores y Especificadores

Calificadores: const

int main()
{
    int number = 0;
    const int constNumber1 = 0;
    int const constNumber2 = 0;
    const int constNumberErr;       /* Error: n4 debe ser inicializado */

    number = 100;
    constNumber1 = 100;             /* Error: No se puede asignar a const */
    constNumber1 = constNumber2;    /* Error: No se puede asignar a const */


    const int &constTempRef = 1;
    const int &constNumbRef = number;
    int &numbReferenceErr = constNumber1;    /* Error: No se puede convertir. */
    const int &constNumbRef2 = constNumber1;

    const int *numberPtr = &number;
    const int * const numberPtr2 = &number;
    int *constNumberPtrErr = &constNumber1;    /* Error: No se puede convertir. */
    const int* constNumbPtr = &constNumber1;

    *numberPtr = 5;             /* Error: El contenido de numberPtr es const */
    numberPtr = new int(0);
    numberPtr2 = new int(5);    /* Error: El apuntador numberPtr2 es const */
}

Calificadores: volatile

#include <iostream>

int main()
{
    for (int x = 0; i < 10; ++i)
    {
        volatile int a = x;            /* Evita que el compilador optimize a */
        std::cout << a << std::endl;
    }

    return 0;
}

Calificadores: mutable

#include <iostream>
#include <string>

class Foo
{
public:
    Foo() : mToStringCtr(0) {}

    std::string name() const
    {
        mName = "Foo";      /* Error: No se pueden modificar miembros en una funcion const */
        return mName;
    }

    std::string toString() const
    {
        ++mToStringCtr;     /* Es posible modificar por que es una variable mutable */
        return "Foo";
    }

private:
    std::string mName;
    mutable unsigned int mToStringCtr;
};
int i = 0;

Introduccion_a_cpp

By Victor Romero

Made with Slides.com

Introduccion_a_cpp

Conceptos básicos de C++

  • 819

More from Victor Romero