Mensajes

[(dia>=0) ? "menor":"mayor"]

Si bien es cierto que está bien usar tipos que concuerden entre sí, yo no recomendaría usar unsigned salvo que sea totalmente necesario.
Fíjate, por ejmeplo, en esto: (dia>=0) ? "menor":"mayor"
dia es unsigned, así que siempre va a ser mayor o igual a 0.
La lógica y las operaciones cambian, además de que conseguiremos fácilmente un underflow al andar haciendo restas sin comprobaciones (sin ir más lejos, si el dia o el mes de [1] es mayor que el de

• saldrán resultados incorrectos).
  
  Y en cuanto a la pregunta original, comparar fechas es como restar. Si el mes de la fecha más alta es menor que el de la más pequeña, igual que en una resta: le restas 1 al año y le sumas 12 al mes. Parecido para los días.

No sirve el cin.clear();
Pero encontre otra alternativa lo dejo aqui, por ahi a alguien le sirve

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstring>
#include <stdio.h> //Libreria para utilizar la funcion gets, fgets, fflush;

using namespace std;

int main(){
char primera[10], segunda[10];
cout << "Primera: ";
fgets(primera, 11, stdin);
fflush(stdin);
cout << "Segunda: ";
fgets(segunda, 11, stdin);
fflush(stdin);
cout << primera << endl;
cout << segunda << endl;
system("pause");
}

Ahora si puedo poner tranquilamente: Nelson Growwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww

El cin.clear(), como dije, limpia flags de error, no resuelve tu problema.

2 cosas importantes:

• Cuando ese getline deja de leer porque se ha llenado el buffer, activa el "failbit", el cual puedes ver si está activado con "cin.fail()", que retorna un bool. Con esto puedes ver si se ha leído el salto de línea o no.
• Para volver a usar cin despues de que una flag de error haya sido establecida, puedes usar "cin.clear()"

Dicho esto, una posible opción sería, tras la lectura, comprobar si está el failbit activado. Y luego, leer con getline en bucle hasta que el failbit no se establezca, lo que significaría que ya se leyó el salto de línea.

Esta lógica la puedes meter en una función para evitar escribirla siempre.


Otro detalle: En C++, en vez de las cabeceras de C,e s preferible usar las cabeceras de C++ que vienen de C, que son las mismas con una "c" al principio y sin el ".h": "stdio.h" => "cstdio"...

Si no pusieras el it2 = ..., it2 dejaría de ser un itrador válido.
Al hacer la asignación, it2 es el siguiente en la lista. Dado que luego se le hace el "--", vuelve para atrás (dado que se eliminó el antiguo it2, es lo mismo que haber hecho "it2--" antes del erase).

Asi que una de 2, o haces la asignación del erase, o te guardas un iterador al elemento anterior.

Sí, se puede hacer lo que dices, y todo lo que tenía la clase padre, lo tendrá la hija (salvo lo private, que no lo podrá ver). Y así recursivamente.

Tal como lo tienes, así es, y no tiene más magia.

Desde luego, si lo que hay en redes sociales es complementario a nuestra forma de ser, y ello pueda influir al entorno laboral... Sin duda debe ser tenido en cuenta.  Pero con cuidado, ya que las redes sociales no siempre describen a una persona.

Es cuestión de que las empresas valoren a la gente por lo que aportan y por las personas que son, y no por lo que han escrito en Twitter en el pasado.

Otra opción, y véase que esta tiene sus contras, es tenes un array static en la función:

Código (c) [Seleccionar] Expandir

char* func(){
    static char arr[50];

    arr[0] = 'H';
    arr[1] = 'o';
    arr[2] = 'l';
    arr[3] = 'a';
    arr[4] = '\0';

    return arr;
}

Una variable static en una función no va a liberarse cuando la función haya retornado, así que puedes retornar su dirección de memoria sin problema.
Si hicieras esto con memoria dinámica, tendrías que recordar el liberarla entre llamadas, o cuando fuera necesario,

Depende de cómo se haya declarado esa cadena.
Si es memoria dinámica, obtenida con malloc o new en C++, puedes devolverla (recordando que habrá que liberarla posteriormente).

Si hablamos de C++, y son cadenas de tipo std:.string o en general, un std::vector o cualquier otra clase del estilo, podrás retornarla sin problemas.

Estás usando Python 2, así que los números que comeinzan por 0 están en octal.
(octal) 101010101 == (decimal) 17043521