Introducción a C++

• Los operadores aritméticos siguen las reglas de la aritméticas tradicionales.

• Los operadores multiplicativos (multiplicación, división y residuo) tienen mayor precedencia que los operadores aditivos (suma y resta).

• Por medio de los paréntesis podemos cambiar la precedencia.

• Los operadores + y - si se utilizan antes de un operando, tienen mayor precedencia y se consideran operadores unarios.

• Las expresiones matemáticas entre paréntesis tienen prioridad sobre todos los operadores.

• Si los paréntesis están anidados se ejecutan de los más internos a los menos internos.

• Las subexpresiones entre paréntesis se evalúan en primer lugar según el modo estándar y los resultados se combinan para evaluar la expresión completa.

• La asociatividad determina el origen en que se agrupan los operadores de igual prioridad, es decir, de izquierda a derecha o de derecha a izquierda.

• Cuando se utilizan los operadores en una expresión, el operador relacional produce un 0 (falso) o un 1 (verdadero).

  • == igualdad

  • != diferente

  • > mayor que

  • < menor que

  • >= mayor igual

  • <= menor que

• Los operadores relacionales tienen menor prioridad que los operadores aritméticos y tienen asociatividad de izquierda a derecha.

• Los operadores relacionales permiten comprobar dos valores.

• El símbolo de igualdad (=) será el operador de asignación.

• Asigna el valor de la derecha a una variable de la izquierda.

• Podemos hacer varias asignaciones evaluadas de derecha a izquierda:

• a = b = c = 10;

• El lenguaje C++ tiene cinco símbolos de asignación o atajos:

  • *=     a*=b    equivale a a = a * b;

  • /=     a/=b    equivale a a = a / b;

  • %=    a%=b  equivale a a = a % b;

  • +=     a+=b  equivale a a = a + b;

  • -=      a-=b   equivale a a = a - b;

• Los operadores de incremento (++) y de decremento (--) suman o restan, respectivamente, una unidad a la variable.

c++ equivale a c = c + 1;

• Estos operadores se pueden utilizar como prefijo o como sufijo.

• Si los operadores están de prefijos (++c), la operación de incremento o decremento se efectúa antes  que la operación de asignación.

• Si los operadores están de sufijos (c++), la asignación se efectúa primero y el incremento o decremento a continuación.

• Los operadores lógicos en C++ son ! (not), && (and) y || (or)

• El operador ! tiene mayor prioridad que &&, y a su vez, && tiene mayor prioridad que ||.

• Los operadores matemáticos (+,-,/,*,%) tienen precedencia sobre los operadores relacionales (<,>,==,!=).

• Los operadores relacionales tienen prioridad sobre los operadores lógicos (&&,||,!).

• El operador condicional u operador ternario ? : regresa un valor dependiendo si la condición es verdadera o falsa.

• Tiene asociatividad de derecha a izquierda.

• Si el resultado de la expresión condicional es verdadero (diferente a cero) regresa el primer valor, si es falso (igual a cero) regresa el valor después de los dos puntos.

El operador coma permite combinar dos o más expresiones separadas por comas en una sola línea.

int a = 10, b = 20;

Se evalúa de izquierda a derecha.

Tiene la más baja prioridad de los operadores.

Los operadores bits trabajan a nivel de bit y sólo aplican en las variables enteras int.

Existen cinco operadores de bits binarias y una unaria.

&, equivale a AND. Compara dos bits, si ambos son 1 el resultado es verdadero (1).

|, equivale a OR. Compara dos bits, si alguno es 1, el resultado es verdadero (1).

~, equivale a NOT. Opera en un bit. Si es 1 es cero y viceversa.

<<, desplaza los bits a la izquierda

>>, desplaza los bits a la derecha

^,, equivale al NOT exclusivo. Si ambos son 1 o ambos son 0, el resultado es 0, de lo contrario es 1.

Determina el tamaño de un tipo de dato o variable que ocupa en memoria en bytes.

sizeof (variable)

sizeof (tipoDato)

sizeof (expresión)

El operador sizeof() es unario.

• Se le llama “conversión de tipos” cuando cambiamos el tipo de una variable sin cambiar su valor.

• Existe la conversión implícita (automática) y la conversión explícita (realizada por el programador).

• Dentro de la conversión implícita, el Lenguaje C++:

• Hace la conversión entre los tipos aritméticos (int, float, double).

• Convierte valores cuando se combinan tipos mixtos de expresiones.

• Convierte valores cuando se pasan parámetros a las funciones.

• Las conversiones más simples se les llaman promociones integrales (por int) convierte los tipos bool, char, unsigned char, signed char y short a int.

• Las conversiones explícitas se realizan por la notación “modelo”:

• (tipoDato) valor

• tipoDato (valor)

• Por medio del operador new podemos obtener bloques de memoria.

• Podemos utilizar el operador new en cualquier tipo de dato.

• El operador new devuelve un puntero o apuntador, que es la dirección del bloque asignado de memoria.

• El tipo de dato del puntero debe coincidir con el tipo de dato solicitado.

• Si hay algún error se produce, el apuntador será NULL.

• Las sintaxis posibles son:

• apuntador = new tipoDato

• apuntador = new tipoDato (inicializador)

• apuntador = new tipoDato [dimensión] ; // para arreglos

  
  

Operador delete

• El operador delete nos sirve para liberar la memoria creada con el operador new.

• El operador delete no borra el apuntador o puntero creado con new.

Apuntes a la sección 2: Expresiones y operadores

• La sentencia if tiene la condición entre paréntesis y las sentencias entre llaves.

• Si sólo hay una sentencia, podemos omitir las llaves.

• Si la condicional se evalúa como verdadera (diferente a cero) se ejecuta el bloque de sentencias.

• Si la condición es falsa (igual a cero) no se ejecuta el bloque de sentencias y continúa el programa.

• Una variación de la sentencia if es la palabra reservada “else”, que ejecuta una sentencia o bloque de sentencias si la condición es falsa (igual a cero).

• Puede existir una sentencia if sin else, pero no puede haber un else sin if.

• Si sólo hay una sentencia, tanto en if como en el else, se pueden omitir las llaves.

• Las sentencias condicionales if se pueden anidar una dentro de otra tanto en el bloque de if o en el bloque else.

• No hay límite en las sentencias anidadas.

• Se recomienda no anidar más de tres estructuras condicionales.

• También se siguen las reglas de las llaves cuando sólo hay una sentencia.

• Cuando tenemos condiciones excluyentes podemos utilizar una estructura de tipo else-if.

• Si ninguna de las condiciones se cumplen, podemos agregar al final una sentencia else.

• Si cada una de las estructuras condicionales sólo tienen una sentencia, podemos omitir las llaves {}.

• Por medio de la sentencia switch podremos seleccionar varias opciones de una variable o expresión simple.

• A esta variable o expresión se le conoce como expresión de control o selector.

• La sintaxis general de esta sentencia es:

switch (selector){

case valor: sentencias;

break;

case valor: sentencias;

break;

case valor: sentencias;

break;

…

default: sentencias;

}

• Cada valor debe de ser único.

• Si no se cumple ningún valor se ejecuta la sentencia default.

• Si se cumple un valor, se ejecutan las sentencias hasta encontrar una sentencia break.

• Los valores de la estructura case deben ser del mismo tipo que el selector.

• El operador condicional u operador ternario ? : regresa un valor dependiendo si la condición es verdadera o falsa.

• Tiene asociatividad de derecha a izquierda.

• Si el resultado de la expresión condicional es verdadero (diferente a cero) regresa el primer valor, si es falso (igual a cero) regresa el valor después de los dos puntos.

Apuntes a la sección 3: Estructuras condicionales

• La sentencia while() primero se hace la expresión condicional y luego el bloque de sentencias.

• También aplican las reglas de las llaves de las estructuras condicionales.

• Cada repetición del bucle se llama “iteración”.

• La sentencia do..while() primero se hace el bloque de sentencias y luego la expresión condicional.

• También aplican las reglas de las llaves de las estructuras condicionales.

• Cada repetición del bucle se llama “iteración”.

• El ciclo for se utiliza, principalmente,  cuando sabes el valor de inicio, el valor final y el incremento.  

• Se puede contar con una o más variables de control del ciclo.  

• El ciclo for se forma de tres partes o expresiones:  

  • Expresión de inicio: establece los valores iniciales de la variable de control.

  • Expresión de control: el ciclo se repetirá mientras esta expresión sea verdadera o diferente de cero.  

  • Expresión de incremento o decremento: Modifica las variables de control del ciclo.  

• Por medio de la sentencia break podemos salir del ciclo o bucle.  

• Siempre se utiliza con una instrucción condicional.  

• Por medio de la sentencia continue repetimos el ciclo sin ejecutar las instrucciones abajo de ella.  

• También se utiliza con una instrucción condicional.  

• Podemos anidar varios ciclos.

• Hay que tener cuidado en que no se confundan las variables de control.

• Podemos utilizar las enumeraciones (enum) dentro de un ciclo for().  

• También podemos crear sentencias nulas en los ciclos for(). 

Apuntes a la sección 4: Estructuras cíclicas

• Una función es un bloque de código de lenguaje C++ que no es ejecutado inmediatamente, sino que puede ser "llamado" o ejecutado desde el código "principal".

• Una función es la definición de una "rutina" (o pequeño programa)  que se puede ejecutar una o varias veces.

• Una analogía típica de una función es una receta de cocina:

• La declaración de una función se le conoce como “prototipo”.

• Un prototipo es la cabecera de la función, pero termina con punto y coma.

• Con los prototipos el compilador verifica las comprobaciones de las llamadas de las funciones.

• Por medio de las tres puntos (...) podemos indicarle a una función, y a su prototipo, que se van a recibir un número indefinido de parámetros.

• Para ello, necesitamos el archivo de cabecera #include <cstdarg> con macros (funciones en línea).

• Dentro de este archivo está definido el tipo de datos va_list.

• La función va_start() inicializa el puntero para manejar la lista de datos pasada a la función.

va_start(va_list puntero,ultimofijo);

• Por omisión los parámetros en las funciones del lenguaje C++ se pasan por valor.

• Si desea pasar un parámetro por referencia hay que utilizar una referencia.

• Para pasar una variable por referencia debemos utilizar & antes del nombre de la variable.

• Las funciones en línea son segmentos de código que el preprocesador las sustituye antes de compilar.

• Son más rápidas que las funciones.

• Se utilizan cuando la función es una expresión, su código es pequeño y es muy utilizado en el programa.

• Con las funciones en línea aumenta el tamaño del código binario.

• Si el programa llama x veces a la función en línea, el preprocesador copiará x veces el código.

• Podemos definir valores por omisión en los parámetros de una función desde el prototipo.

• Sólo los últimos parámetros de las funciones pueden tener valores por omisión.

• Sólo los últimos parámetros pueden ser omitidos cuando se llama a una función.

• Cada uno de los valores por defecto debe especificarse bien en los prototipos, o bien en las declaraciones, pero no en ambos.

• Podemos pasar un apuntador o puntero como parámetro de una función.

• Un apuntador es un objeto, por lo cual se pasará por referencia.

• El nombre de un arreglo en realidad es un apuntador al inicio del objeto.

• Si pasamos un arreglo como parámetro a una función, lo pasamos como referencia.

• Sin embargo, tenemos problemas para determinar el tamaño del arreglo, sobre todo cuando manejamos arreglos de varias dimensiones dentro de una función.

Cuando pasamos un arreglo de más de una dimensión es obligatorio pasar el número de elementos en las siguientes dimensiones dentro de los paréntesis.

• Una función puede regresar una referencia.

• La función prototipo es:

   <tipoDato> &<nombreFuncion>(<parámetros>);

• Las funciones recursivas son aquellas que se llaman a sí mismas dentro de su bloque de sentencias.

• Debe existir alguna condición de terminación de las llamadas recursivas para evitar un bucle infinito de llamadas.

• Podemos “pasar” valores desde la llamada al programa del sistema operativo.

• Recibimos dos parámetros: el primero es argc (argument counter), que es el número de parámetros que escribimos, y el segundo es un apuntador a un arreglo con los datos que escribimos (*argv[] argument values).

• El primer elemento (el cero) de este arreglo es el nombre del programa.

• Algunas funciones de librerías requieren que pasemos un apuntador de la función como parámetro.

• Por ejemplo, la función qsort() requiere en sus parámetros una función de comparación que debemos hacerla nosotros.

• La función qsort() se encuentra en el archivo de cabecera <cstdlib>.

Apuntes a la sección 5: Las funciones en el lenguaje C++

• rand(void): RAND_MAX en <cstdlib>

• srand(semilla): Inicializa el generador de número aleatorio. Se utiliza para el punto de inicio o semilla.

Aplicaremos las funciones aleatorias para crear un juego del número mágico. 

Por medio de las funciones aleatorias podemos “barajar” o desordenar un arreglo. 

• fabs (x), Valor absoluto de x

• ceil (x), Redondeo entero superior

• pow (x, y), Potencia de x elevado a y

• floor (x), Redondeo entero inferior

• sqrt (x), Raíz cuadrada de x

• exp (x), Exponenciación (número e elevado a x, siendo e = 2.71828)

• sin (x), Seno de x

• log (x), Logaritmo neperiano de x

• sin (x), Seno de x

• cos (x), Coseno de x

• tan (x), Tangente de x

• sinh (x), Seno hiperbólico de x

• cosh (x), Coseno hiperbólico de x

• tanh (x), Tangente hiperbólico de x

• atan (x), Arcotangente de x

• atan2 (x,y), Arcotangente de x e y

• time: toma el tiempo de la computadora.

• difftime: diferencia de valores de tiempo.

• gmtime: convierte time_t en formato UTF_time (apuntador)

• asctime: convierte time_t en cadena (apuntador)

struct tm {

    int tm_sec;        seconds after the minute (from 0)

    int tm_min;        minutes after the hour (from 0)

    int tm_hour;       hour of the day (from 0)

    int tm_mday;       day of the month (from 1)

    int tm_mon;        month of the year (from 0)

    int tm_year;       years since 1900 (from 0)

    int tm_wday;       days since Sunday (from 0)

    int tm_yday;       day of the year (from 0)

    int tm_isdst;      Daylight Saving Time flag

    };

• strcpy: copia la cadena 2 a la cadena 1.

• char *strcpy(char *s1, const char *s2);

• strcat: añade la cadena 2 a la cadena 1:

• char *strcat(char*s1, const char *s2);

• strcmp: regresa un valor mayor que 1 si la cadena s1 es mayor que s2, regresa un valor -1 si la cadena s1 es menor a s2 y regresa 0 si son iguales.

• int strcmp(const char *s1, const char *s2);

• strlen: determina el número de caracteres de una cadena.

• size_t strlen(const char *s);

• strtok: divide una cadena en diferentes tokens o sub cadenas dependiendo de los delimitadores en s2.

• char *strtok(char *s1, const char *s2);

Apuntes a la sección 6: Funciones ANSI C

• Una estructura es una colección de diferente tipos de datos.

• A cada elemento de una estructura se le llama miembro.

• Una definición de una estructura es:

Para poblar o acceder a la información de un miembro de la estructura, podemos utilizar la notación punto o, por medio de un puntero, utilizar la flecha:

<variable estructura>.<miembro>

   O

 <puntero estructura>-><miembro>

• Dentro de una estructura podemos utilizar otras estructuras.

• Se consideran estructuras anidadas.

• Accedemos a los datos por los puntos o por los apuntadores (punteros).

• Por medio de la palabra reservada typedef podemos definir  nuestros propios tipos de datos a partir de los tipos básicos del Lenguaje C++.

• Su sintaxis sería:

typedef <tipoDatoExistente> <nuevoNombre>

• Podemos definir un arreglo de estructuras.

• Accedemos a la información con el elemento del arreglo y la notación punto.

• Podemos crear estructuras anónimas, es decir, sin nombre, pero sólo dentro de otra estructura o unión.

• Se llaman con la notación punto como cualquier otro elemento de la estructura.

• Las uniones son estructuras que permiten almacenar diferentes elementos de diferente tipo en el mismo espacio, pero no en forma

union [<identificador>] {

  [<tipo> <nombre_variable>[,<nombre_variable>,...]];

} [<variable_union>[,<variable_union>,...];

• Todos los miembros de una unión ocupan el mismo espacio e inician en el mismo punto.

• La longitud de una unión es su miembro más largo.

• El operador sizeof() nos indicará la longitud de la unión en bytes.

Apuntes a la sección 7: Estructuras y uniones

• Un apuntador o puntero es una variable que contiene la dirección de memoria de otra variable.

• Cuando se declara una variable se asigna nombre, dirección y tipo.

• Los apuntadores deben ser declarados ANTES de ser utilizados.

• Para declarar un apuntador precedemos un asterisco (*) a su nombre.

• Hay que inicializar (o iniciar) el apuntador ANTES de utilizarlo.

• Para asignar una variable de memoria a un apuntador utilizamos el &.

• El operador asterisco (*) también sirve para obtener el contenido de una variable apuntador o para modificar el contenido del objeto apuntado.

• Un apuntador nulo no apunta a ningún segmento de memoria.

• Para crear un apuntador nulo le asignamos la constante NULL (que tiene el valor de cero).

• También puedes declarar un apuntador nulo asignándole el número cero.

• Un apuntador genérico puede apuntar a cualquier tipo de dato pero para consultar los datos, debes de definirlo *(tipo dato*)prt

• Un apuntador puede apuntar a otro apuntador.

• Para declarar un apuntador a un apuntador usamos dos asterísticos (**) y así sucesivamente.

• En el Lenguaje C++ se pueden direccionar arreglos como apuntadores y apuntadores como arreglos.

• El nombre de un arreglo es en realidad un apuntador constante.

• Se puede utilizar la notación de apuntadores para visualizar un elemento en un arreglo.

• Podemos hacer un arreglo de apuntadores.

• Apuntan a un mismo tipo de dato.

• Un arreglo de arreglos (tabla o matriz) es un arreglo que apunta a otros arreglos (columnas).

• Una cadena es un arreglo de caracteres en el Lenguaje C++.

• El nombre del arreglo (de cualquier tipo) es un apuntador.

• Por lo tanto, una cadena la podemos manejar con un apuntador o como un arreglo.

• Un apuntador constante no puede cambiar el objeto al que apunta.

• El contenido del objeto apuntado si puede cambiar.

• Si el apuntador a una constante si puede cambiar, pero el contenido de la constante no puede cambiar.

• Para crear un apuntador constante se utiliza la siguiente sintaxis:

• <tipoDato> *const <puntero> = <dirección>

• También puede haber apuntadores constantes que apuntan a constantes.

• Los apuntadores o punteros también puede apuntar a una estructura.

• Apunta de la misma manera que a otras variables.

<struct> <identificador> *variable

• Para acceder a los datos utilizamos el apuntador y el operador ->.

• Los apuntadores o punteros (que no sean constantes) son variables que se pueden modificar.

• A los apuntadores podemos sumarles y restarles un número entero. Esto hace que apunte n posiciones adelante o atrás.

• A una variable apuntador se le puede aplicar los operadores ++ y --.

• No se pueden sumar dos apuntadores entre ellos, ni multiplicar, ni dividir.

Apuntes a la sección 8: Apuntadores

• Un espacio de nombres o namespaces es un archivo separado donde podemos definir tipos de datos, clases, estructuras, funciones, etc. al que se le asigna un identificador propio.

• De momento hemos trabajado en lo que se denomina “espacio global”.

• Los espacios de nombres nos permiten evitar los errores de “colisión de nomenclaturas” en desarrollos grandes o con las bibliotecas externas.

• Creamos un archivo de encabezado con la extensión “.h”.

• Llamamos al archivo de encabezado con la directiva con “#include”.

• Activamos el espacio de nombres con “using namespace”.

• Podemos llamar a un espacio de nombres con el operador ::

• Podemos crear un alias a un espacio de nombres.

¿Qué es un objeto?

• Un objeto lo podemos definir como un conjunto de métodos y propiedades que responden a ciertos eventos.

Por ejemplo, un gato tiene características y tiene acciones que lo hacen único:

• Características o propiedades: Color de pelo, forma de las orejas, peso edad, raza, color de ojos, género, forma de la cola, etcétera.

• Acciones que hacen los gatos: ronronear, maullar, comer, dormir, trepar, correr, saltar, cazar ratones, etcétera.

• Los gatos, a diferencia de otros animales, como los perros, responden a diferentes eventos.

• La definición básica de una clase es:

class <identificador>{

private:

<listado de propiedades y métodos>

public:

<listado de propiedades y métodos>

protected:

<listado de propiedades y métodos>

}

• Por lo general, las clases se almacenan en archivos de cabecera con extensión “h”.

• La clase se llama con #include.

• Los métodos pueden ser definidos dentro de la clase (prototipos) e implementados fuera de la clase, pero dentro del archivo de encabezado.

• Las funciones constructoras o constructores son funciones que nos permiten iniciar las instancias de las clases,

• El nombre de las funciones constructoras deben tener el mismo nombre de las clases.

• No regresan ningún valor, por lo que no tienen ningún tipo de dato, ni siquiera void.

• Tienen que ser públicas, nunca privadas o protegidas.

• Las funciones constructoras no se pueden heredar.

• Podemos iniciar los datos de la función constructora invocando los constructores implícitos antes de las llaves {} de la función constructores.

• Sólo los constructores aceptan los inicializadores.

• Separamos los paréntesis de la función constructora de los inicializadores por medio de dos puntos (:).

• Se considera más óptimo usar inicializadores a la asignación tradicional.

• Podemos sobrecargar las  funciones constructoras.

• Podemos crear parámetros por omisión en las funciones constructoras.

• La asignación entre objetos de la misma clase está permitida.

• Podemos crear funciones constructoras “de copia”.

• Tienen el mismo nombre de la clase, pero le anteponemos una tilde (~).

• No regresa ningún valor y no necesita tipo de dato.

• No puede ser heredado, debe ser público y no lleva parámetros.

• No puede ser sobrecargado.

• El apuntador this apunta a los elementos o miembros de su clase.

• Utilizamos el apuntador flecha.

Apuntes a la sección 9: Espacios de nombres y clases

• Podemos declarar a una clase como amiga para que tenga acceso a toda la información de la clase (privados, protegidos y públicos).

• La amistad también puede existir entre clases.

• Utilizamos la palabra reservada friend.

• La función amiga puede encontrarse en otra clase.

• El procedimiento es el mismo para declarar funciones amigas externas, solo hay que utilizar el nombre de la clase y el operador de resolución de alcance (::)

• Es más sencillo hacer dos clases amigas.

• La amistad no puede transferir.

• La amistad no se puede heredar.

• La amistad no es simétrica.

• Una regla general de la programación orientada a objetos es que el usuario de la clase NUNCA debe tener acceso directo a los datos de la clase.

• La única forma de acceder a los datos es por medio de funciones intermediarias, o setters (actualizan los datos) y getters (recuperan los datos).

• Podemos crear funciones en línea en una clase.

• Hay que definir el prototipo dentro de la clase y la implementación de la misma, afuera de la definición de la clase.

• La función debe ser pequeña.

• Las funciones implementadas en la definición de la clase, se consideran inline por omisión.

• Si reservamos una palabra reservada const entre los paréntesis y las llaves, el compilador impide que se modifiquen los datos dentro de la función.

• Es muy útil para los getters.

• Podemos marcar a una función para que regrese un valor constante con el modificador const.

• Es especialmente útil cuando regresamos apuntadores o punteros.

Podemos sobrecargar funciones miembro o métodos en una clase con la misma restricción que las funciones globales: no pueden tener el mismo número y tipo de datos de parámetros. 

• En estructuras y en clases no podemos utilizar directamente muchos operadores como los aritméticos, como la suma, la resta, etc.

• Podemos crear funciones para ello.

• También podemos crear operadores “sobrecargados” que regresen un valor equivalente a los operadores aritméticos.

• Los operadores que no se pueden sobrecargar son:

• Acceso a miembros de la clase (.)

• Indirección a miembros de la clase (.*)

• Resolución de ámbito (::)

• Operador condicional (? : )

Podemos sobrecargar operadores unarios, como ++ o == para la operación entre clases. 

• Las clases no tienen conversión implícita  entre ellas.

• Necesitamos escribir nuestras funciones de conversión con las siguientes característica:

• La función de conversión debe ser un método de la clase a convertir.

• La función de conversión No debe especificar un tipo de retorno.

• La función de conversión No debe tener argumentos.

• El nombre de la función debe ser el del tipo al que se quiere convertir el objeto.

Apuntes a la sección 10: funciones amigas y modificadores