No he visto tu código original, pero seguramente, el ejemplo que has pillado sería equivalente al siguiente:

const wchar_t* wstr = /* lo que sea */; // Cadena const.
unsigned char* ustr = reinterpret_cast<unsigned char*>(const_cast<wchar_t*>(wstr));

Sin embargo, tú tendrás lo siguiente:

wchar_t* wstr = /* lo que sea */; // Cadena no-const.
unsigned char* ustr = reinterpret_cast<unsigned char*>(const_cast<wchar_t*>(wstr));

El error está en el `const_cast`. El `const_cast` sirve para quitar/poner el calificativo `const` a un puntero o una referencia. Ejemplos:

int a = 3;
 
// Ok, const_cast recibe un puntero (int*) y lo convierto a puntero-a-constante (const int*).
const int* ptr_a = const_cast<const int*>(&a); 
const int* ptr2_a = &a; // Ok, la conversion a const tambien funciona de forma implicita.
 
// Aqui el `const_cast` es absolutamente necesario. Quitarle `const` a un puntero/referencia nunca
// es implicito (ponerselo si), y hay que forzarlo con `const_cast`.
int* ptr3_a = const_cast<int*>(ptr_a);
 
// Este es el error de tu codigo! `ptr3_a` no es constante, y el tipo de salida del casting, tampoco (int*),
// pero `const_cast` requiere que uno de los dos sea constante y el otro no! Si los dos son iguales
// te da un error de compilacion.
int* ptr4_a = const_cast<int*>(ptr3_a);

No he puesto ejemplos con referencias porque no es tu caso. ¿Cuál es tu problema? Que tu `const_cast<wchar_t*>(wstr)` está diciendo: "quítale el `const` a `wstr`", pero `wstr` resulta que no es `const`, así que no hay nada que quitar, y de ahí el error de compilación. De todas formas, utilizar un `const_cast` es peligroso, y podría provocar incluso violaciones de segmento (especialmente con cadenas). Si algo se marco como `const`, es por algo.

Bueno, continuemos. ¿Y qué es lo que hace `reinterpret_cast<tipo>(var)`? Pues sencillamente lo siguiente: coje la dirección de memoria de la variable que le has pasado, y a partir de ahí, coje `sizeof(tipo)` bytes y lo devuelve como un objeto de tipo `tipo`. Ajin! Completamente a pelo, y éso es muy peligroso.

Por ejemplo (relacionandolo con tu caso):

wchar_t wc = /* un caracter, el que sea */
unsigned char c = reinterpret_cast<unsigned char>(wc);

Veamos el peligro: al menos en mi arquitectura, `sizeof(wc) == 4`, mientras que `sizeof(char) == 1`. Al realizar dicho `reinterpret_cast`, el compilador coje el primer byte the `wc` y devuelve la secuencia de bits como un `unsigned char`, sin adaptar la representación ni nada, y `c` tendría una copia del primer byte the `wc`.

¿Qué pasa con cadenas/punteros?

wchar_t* wc = /* lo que sea. Cadena de 5 caracteres. */
unsigned char* c = reinterpret_cast<unsigned char*>(wc);

Aquí `wc` es un puntero (y todos los punteros tienen el mismo tamaño en una misma arquitectura), así que `reinterpret_cast`  devuelve la misma dirección de memoria, pero ahora desde `c` estás manipulando `unsigned char`s y no `wchar_t`s. Así que:

for (unsigned i = 0; i < 5; ++i)
    cout << c[i] << endl;

Aquí, tu crees que estás imprimiendo los 5 primeros carácteres de la cadena original (transformada como `unsigned char`), pero resulta que estás imprimiendo ¡los 4 primeros bytes del primer carácter de la cadena `wchar_t` original, más el primer byte de la segunda! Habría que hacerlo de la siguiente forma:

for (unsigned i = 0; i < 5 * sizeof(wchar_t); ++i)
    cout << c[i] << endl;

Además, utilizarlo de la siguiente forma tiene muchos riesgos, el más importante es que `wchar_t` es un tipo muy especial, cuya implementación es a gusto del compilador, así que en teoría, no hay forma de saber cómo está representado cada carácter. ¿Están los bytes puestos de abajo a arriba? ¿De arriba a bajo? ¿Con complemento a uno o a dos? ¿Cada carácter tiene 2 bytes, 4 u 8?

Así que, si trabajar con `reinterpret_cast` es peligroso de por sí (solo debe usarse en situaciones muy controladas), y utilizarlo para llegar de `wchar_t` a `char` lo es más aún.

Siempre que puedas, utiliza `char*`, a no ser que sea exclusivamente necesario.

Ok. Aquí el mío, con las comprobaciones siguientes:

• Detección de signo '+' (línea 34).
• Escape de prefijo de 0s (línea 37).
• Detección de número demasiado grande capturando desbordamiento (línea 15).
• Paramétrico: acepta cualquier tipo númerico, sin importar si es signed o unsigned, ni su tamaño (short, long, long long), ni los detalles de la arquitectura: si la arquitectura utiliza complemento a dos para representar números, por ejemplo para el caso `sizeof(int) == 4`, el rango va desde -2^31 hasta 2^31-1, pero si utiliza complemento a uno, va desde -2^31+1 hasta 2^31-1, para números sin signo.
• Si se desea un `unsigned`, pero se ha introducido el signo `-`, también lanza error (línea 31).
• He hecho la función recursiva para ahorrar líneas (sustituir asignaciones por parámetros). No me gusta poner en foros códigos muy largos. De todas formas, el compilador seguramente la cambiará por una función iterativa sin mucho esfuerzo.

Código en coliru: http://coliru.stacked-crooked.com/a/bf7bfac2d1b46842 (haced click en `Edit` y cambiar la entrada por el número que queráis para probar el programa).

Aquí una lista de los límites numéricos según la arquitectura (sección Range of values): http://en.cppreference.com/w/cpp/language/types, por si queréis hacer pruebas.

Para cambiar el tipo que deseáis obtener, cambiad el que aparece en la línea 48: `getNum<tipo>(str)`.

#include <iostream>
#include <stdexcept>
#include <type_traits>
 
using namespace std;
 
template<typename Num_t> // Funcion recursiva, caracter a caracter.
Num_t getNum(string const& str, Num_t num, signed char sign, size_t i, unsigned char nextc)
{
    if (i == str.size()) return num;
    if (nextc > 9) throw invalid_argument("Eso no es un numero.");
 
    Num_t next = num * 10 + sign * nextc;
 
    if (sign == 1 ? (next < num) : (next > num))
        throw invalid_argument("Numero demasiado grande.");
 
    return getNum(str, next, sign, i + 1, str[i + 1] - '0');
}
 
template<typename Num_t>
Num_t getNum(string const& str)
{
    if (str.size() == 0) throw invalid_argument("Introduzca un numero.");
 
    size_t i = 0;
    signed char sign = 1;
 
    if (str[i] == '-') {
        if (is_unsigned<Num_t>::value)
            throw invalid_argument("Un numero natural no puede ser < 0.");
 
        ++i; sign = -1;
    } else if (str[i] == '+')
        ++i;
 
    while (str[i] == '0') ++i; // Ignoramos prefijo de 0s.
 
    return getNum<Num_t>(str, 0, sign, i, str[i] - '0');
}
 
int main()
{   
    while (cin.good()) // Hasta que no me des un numero (y quede entrada) no te escapas.
        try {
            string str;
            getline(cin, str); cin.ignore();
            cout << getNum<unsigned>(str) << endl;
            break;
        } catch (invalid_argument const& e) {
            cerr << e.what() << endl;
        }
 
    return 0;
}

Nota sobre chars: Mientras que el tipo `char` se utiliza para manipular carácteres, los tipos `signed char` y `unsigned char` se utilizan para manipular números de 1 byte (si `char` tiene signo o no, se deja a criterio del compilador). Si queréis utilizar éste programa para capturar números en el rango [-127, 127], [-128, 127] o [0, 255] (ya sabéis, números de 1 byte, signed/unsigned), la línea 48 no imprime el número, sino el carácter correspondiente devuelto por `getNum`. Tenéis que hacer un casting en ese caso a `int` por ejemplo para imprimir el número.

Aunque por supuesto, siempre hay solución para ello, sin tener que hacer casting manual

// Alias de `std::conditional`, para que `char2Short` y `RetNum` no queden muy largos.
template<bool b, typename T, typename F>
using conditional_t = typename conditional<b, T, F>::type;
 
// Transformacion char -> short conservando signo.
template<typename T>
using char2Short = conditional_t<is_signed<T>::value, short, unsigned short>;
 
// Nos aseguramos de devolver al menos un short, para que el
// numero se imprima bien.
template<typename T>
using RetNum = conditional_t<sizeof(T) == 1, char2Short<T>, T>;
 
// Sobrecarga recursiva de `getNum` sin cambios, ya que si devolviese un `short` cuando
// estamos trabajando con `char`s, podría fallar la comprobación de desbordamiento (no
// estoy seguro en realidad).
 
template<typename Num_t>
RetNum<Num_t> getNum(string const& str)
{ /* Implementacion */ }
 
// Main con getNum<char>(str) o getNum<signed char>(str), por ejemplo ...

Si nos ponemos pedantes, ese código de Gunhack sufre dos defectos:

• La operación de obtener el número y la de notificar al usuario del error y el reintento, están acoplados.
• ¿Y si mañana quisieses cambiar el tipo de número a `unsigned`, `long long int` o `long double`?

En mi caso, bastaría con:

#include <iostream>
#include <stdexcept>
 
using namespace std;
 
#define READ_TYPE int
 
template<typename Num_t>
Num_t getNumero()
{
   Num_t numero; cin >> numero;
 
   // A partir de aquí, ya no hay más referencias al tipo.
   if (cin.fail())
      throw domain_error("Hey!!! Eso no es un numero!!");
 
   char c; cin >> c;
 
   if (!cin.fail())
       throw domain_error("Hey!! Has escrito algo mas detras del numero!!");
 
   return numero;
}
 
int main()
{
   while (true) { // Hasta que el número no sea correcto, no te escapas.
     try {
          cout << getNumero<READ_TYPE>() << endl;
          break;
     } catch (domain_error const& e) {
         cerr << e.what() << endl;
     }
   }
 
   return 0;
}
 

Y el tipo que deseo obtener lo puedo especificar pasándole el valor de la macro al compilador (con la opción `-Dmacro=valor` en `gcc` si no me equivoco), así que no tengo que tocar el código si quiero cambiar el tipo.

En el caso de Gunhack, habría que cambiar el tamaño del búfer, y eso no es una tarea tan sencilla: ¿cuántos dígitos requiere un `long int`? http://en.wikipedia.org/wiki/64-bit_computing#64-bit_data_models Seguramente con metaprogramación, `constexpr`s y la librería `<climits>` se pueden obtener buenas cotas, pero ¿y qué pasa con números flotantes? En fin...

La ventaja del código de Gunhack, por otro lado, es que en caso error, su alternativa es claramente menos costosa que la basada en excepciones, pero a veces hay que sacrificar eficiencia a cambio de diseño.

Aunque bueno, éstas consideraciones se escapan al objetivo del ejercicio de Mario, pero he dicho al inicio de la respuesta que estamos en pedantic mode.

#include <stdio.h>
 
int main()
{
   unsigned numero;
 
   scanf("%u", &numero);
 
   if (numero > 100) {
      printf("Numero incorrecto\n");
      return 1;
   }
 
   for (unsigned i = 0; i < numero; ++i)
      printf("%c", 'A');
 
   printf("\n"); // Salto de linea extra, para que la salida quede mas bonita.
 
   return 0;
}
 

Por razones que entenderás en el futuro, un programa, si termina exitosamente, debe devolver un 0, y si termina con errores, debe devolver un 1. Por eso en el `if` he devuelto 1 (ha ocurrido un error), mientras que al final del main, he devuelto un 0.

Siempre ten presente que las funciones deben hacer una sola cosa (o construir una cadena inversa, o imprimirla, pero no ambas). Como tú solamente quieres imprimir, pues que `reverse` imprima, sin más dilación. Si sigues éste principio, tus códigos quedarán siempre mucho más claros. Por otro lado, siempre que trabajes con tamaños e índices, utiliza `size_t`, que no es más que un alias de `unsigned`, pero está pensado precisamente para recorridos y tamaños (`int` y `unsigned` deberían ser usados para problemas más "numéricos" o matemáticos).

void reverse(char const* str)
{
   // Bucle en dirección inversa.
   for (size_t i = strlen(str) - 1; i >= 0; --i)
      cout << str[i];
 
   cout << endl;
}
 
int main()
{
   reverse("linda");
 
   system("pause");
 
   return 0;
}
 

Un truco aprendido por ahí, que simplifica mucho el trabajo, es utilizar "-->", que no es un operador, sino sencillamente, postdecremento y "mayor que", pero se escriben juntos para que parezca una flechita en dirección al 0 (salida del bucle):

void reverse(char const* str)
{
   size_t i = strlen(str);
 
   while (i --> 0)
      cout << str[i];
 
   cout << endl;
}
 

Queda aún más claro, y más legible. Al utilizar un postdecremento de `i`, y suponiéndo que strlen(str) == 5, el `while` va a comparar `i` con los valores 5, 4, 3, 2 y 1 (5 elementos, todos mayores que cero), pero dentro del `while`, debido a que el postdecremento actúa más tarde, los valores serán 4, 3, 2, 1 y 0 (los índices de la cadena), y además, en órden inverso, que es justo lo que quieres.

Si lo que quisieras fuera construir la cadena inversa, e imprimirla fuera, siguiendo el principio de que cada función haga solamente una cosa, pues podría ser así:

// La cadena devuelta por `reverse` es dinámica, y el usuario de la función es responsable de
// eliminarla.
char* reverse(char const* str)
{
   size_t len = strlen(str);
   char* rev = new char[len + 1]; // 1 extra para el '\0'.
 
   for (size_t i = 0; i < len; ++i)
      rev[i] = str[len - i - 1];
 
   rev[len] = '\0';
 
   return rev;
}
 
int main()
{
   char const* rev = reverse("linda");
 
   cout << rev << endl;
 
   delete[] rev;
 
   system("pause");
 
   return 0;
}
 

En la sección de inicialización del `for` solo puedes tener una declaración compuesta. Es decir, tantas variables como quieras, pero del mismo tipo, separadas por comas:
 

#include <iostream>
 
using namespace std; // Mas comodo incluir todo el espacio de nombres.
 
int main()
{
   // Variables
   int palindromo;
   bool respuesta = true;
 
   cout << "palindromo: ";
   cin >> palindromo;
 
   // He borrado el segundo `int`. En la sección de "tests", puedes tener varias expresiones separadas
   // por comas, pero tu quieres que se cumplan todas, asi que utiliza un `and`.
   for(int divMayor = 10000, divMenor = 10; divMenor <= 10000 and divMayor >= 10; divMenor *= 10, divMayor /= 10)
   {
      if ((palindromo / divMayor) != (palindromo / divMenor)) {	
         respuesta = false;
         break;
      }
 
      palindromo %= divMayor;
      palindromo /= divMenor;
   }
 
   // Con poner `if (respuesta)` es suficiente.
   // Por otro lado, estructuras de control (`if/else`, `while`, `for` y `do-while`) que solo
   // tengan una sentencia, no necesitan llaves.
   // Por ultimo, puedes utilizar `std::endl` en vez de `\n`.
   cout << endl;
 
   if (respuesta)
      cout << "El numero es un palindromo.";
   else
      cout << "El numero no es un palindromo.";
 
   // No necesitas `cin.get();` aqui.
   return 0;
}

Primera cosa. Añadid las etiquetas de "código" en el código para que se vea bien (como lo tengo yo abajo). Escribid "[ code=c]" (sin el espacio detrás de `[`) al principio de vuestro código, y "[ /code]" al final (sin el espacio también).

Segundo, ni idea de qué hace vuestro algoritmo, pero os comento un par de fallos que he visto.

Por otro lado, en vuestro relleno de columnas. En vuestro código teníais "columnas * sizeof(double*)", pero cada fila se rellena con una matriz de `double`s y no con punteros. Aunque `sizeof(double) == sizeof(double*)` normalmente, es casualidad. Si una arquitectura tiene palabras de 64 bits pero solo direcciona hasta 32 bits de memoria, `sizeof(double) == 8` pero `sizeof(double*) == 4`. Así que:

for(i = 0; i < filas; ++i) { // Preincremento (++i) siempre mejor que postdecremento (i++).
   matriz = (double*)malloc(columnas * sizeof(double));
 
   if(matriz == NULL) {
      printf("No se ha podido reservar espacio de memoria.\n");
      // getchar(); Para que necesitas `getchar`?
      exit(EXIT_FAILURE); // `EXIT_FAILURE` (= 1, pero mas sano). Necesitas <stdlib.h> para usarlo. 
   }
}
 

Al comienzo del algoritmo puede haber un riesgo con la memoria (te lo pongo en comentarios). Por otro lado, acostumbraos a quitad llaves cuando no son necesarias (si una estructura de control -if/else, for, while, do-while, solo contiene una sentencia, las llaves no son necesarias), y a utilizar preincrementos en vez de postincrementos (y a poner espacios entre operadores por cuestiones de legibilidad). Comparadad como queda el código (mucho más legible y corto):

// Cuidado con la linea (1): aqui asumes que el numero de filas y de columnas coinciden, sin embargo
// al inicio del `main` has permitido que el usuario inicialice ambas. Y si el numero de filas es mayor
// que el de columnas? Que cuando `iteracion >= filas`, la linea (1) provocara un `segmentation fault`.
// Si necesitas que la matriz sea cuadrada, pide al usuario solo las filas e inicializa columnas con el 
// mismo valor.
while(iteracion < filas) {
 
   pivote = matriz[iteracion][iteracion]; // (1)
 
   for(i = 0; i < columnas; ++i) // Aqui no necesitas llaves. Este `for` solamente tiene una sentencia.
      num[iteracion] = matriz[iteracion];
 
   for(i = 0; i < filas; ++i) // Igual, fuera llaves. Y preincremento de nuevo.
      if(iteracion != i) // Fuera llaves.
         num[iteracion] = 0;
 
   for(i = 0; i < filas; ++i) // Fuera llaves. Preincremento.
      for(j = 0; j < columnas; ++j)  // Idem.
         if(i != iteracion && j != iteracion) // Union de ifs.
            num[j] = (((matriz[j] * pivote) - (matriz[iteracion][j] * matriz[iteracion])) / pivant);
 
   ++iteracion; // Preincremento.
   pivant = pivote; // Algo de espacio entre `for`s y sentencias normales, para que no haya claustrofobia.
 
   for(i = 0; i < filas; ++i) // Preincremento. Llaves
      for(j = 0; j < columnas; ++j) // Preincremento. Llaves.
         matriz[j] = num[j];
}
 

¿Excesivo? Te quedas corto xD.

Es mucho más fácil y corto así:

#include <iostream>
#include <stdexcept>
 
using namespace std;
 
int getNumero()
{
   int numero; cin >> numero;
 
   if (cin.fail())
      throw domain_error("Hey!!! Eso no es un numero!!");
 
   char c; cin >> c;
 
   if (!cin.fail())
       throw domain_error("Hey!!! Has escrito algo mas detras del numero!!");
 
   return numero;
}
 
int main()
{
   while (true) { // Hasta que el numero no sea correcto, no te escapas.
     try {
          cout << getNumero() << endl;
          break;
     } catch (domain_error const& e) {
         cerr << e.what() << endl;
     }
   }
 
   return 0;
}
 

Si estás empezando con C++ y te quedas un poco a cuadros con éste código (nadie ha dicho que C++ fuera fácil), pues ve investigando por Internet una a una las funciones y operadores que he utilizado aquí para que lo vayas desgranando, pero fundamentalmente, lo que veo que has malinterpretado es cómo se comportan los flujos en C++ (cin). Ellos ya hacen un montón de trabajo de parseo por tí.

Consejo: no reinventes la rueda. Cada vez que veas algo que sea simple, pero que implique mucho trabajo, seguramente ya esté hecho en algún lugar.

Mod: etiqueta GeSHi modificada, debe ser code=cpp, no code=c++

#include "stdio.h"
#include "time.h"
 
#define SEGS_DIA 86400
 
int main()
{
  struct tm fecha = {}; // Inicializamos la estructura a 0.
 
  // Asumimos que el formato de fecha introducido por el usuario es correcto.
  printf("Introduce la fecha: ");
  scanf("%u%u%u", &fecha.tm_mday, &fecha.tm_mon, &fecha.tm_year);
 
  --fecha.tm_mon; // La estructura tm numera los meses del 0 al 11.
  fecha.tm_year -= 1900; // Los annos comienzan en 1900.
 
  // No utilizo difftime porque devuelve un `double` y me da coraje.
  int diff = (mktime(&fecha) - time(NULL)) / SEGS_DIA;
 
  printf("\nLa diferencia es: %d\n", diff);
 
  return 1;
}
 

Si quisiéramos comprobar el formato de entrada mejor, el `scanf` sería algo más "complejo":

char truco;
 
int leidos = scanf("%2u%2u%4u%c", &fecha.tm_mday, &fecha.tm_mon, &fecha.tm_year, &truco);
 
if (leidos != 3)
  exit(EXIT_FAILURE);
 
if (tm_year < 1000) // Asumimos que el anno debe tener al menos 4 digitos.
  exit(EXIT_FAILURE);
 

Los numeritos (el 2 o el 4) son para indicar el "ancho" máximo que tendrá cada campo. El otro "truco" (la `%c` final) sirve para evitar que el usuario introduzca cadenas más largas de la cuenta; por ejemplo: "24 11 19900asd". El formato de entrada sería correcto para `scanf`, porque los cuatro primeros dígitos del campo "año" se guardan correctamente.

El problema es que `scanf` deja de "leer" e ignora el resto de la cadena, así que lo forzamos a leer al menos uno más, y si ha recuperado 4, es que la cadena era demasiado larga.

Si el órden de los elementos no importa, puedes utilizar un `set` auxiliar (no he probado el código):

void eliminarRepetidos(vector<int>& v)
{
    set<int> sinReps;
 
    for (auto& i : v)
       sinReps.insert(i); // Los elementos repetidos no se insertan en un set.
 
    vector<int> nuevo;
 
    for (auto& i : sinReps)
        nuevo.push_back(i);
 
    // `nuevo` no tendrá elementos repetidos. Efecto secundario: ahora estará ordenado.
    // Sustituimos `v` por `nuevo`.
    v = nuevo;
}