Mensajes

En vez de usar la entrada con std::cin >>, te aconsejo usar la función std::getline:

Código (cpp) [Seleccionar] Expandir

std::getline(std::cin, nombreDelObjetoString);

No he comprobado que funcione.

Entonces, lo único que se me ocurre es que almacenes la cadena en un vector de chars:

Código (cpp) [Seleccionar] Expandir

std::vector<char> cData;
const char *lpbyData = "aisjiajisfj\0buenas";
size_t uNumCharacters = 19;

cData.reserve(uNumCharacters);

for(int i = 0; i < uNumCharacters; i++) {
    cData[i] = lpbyData[i];
}

Esta es la función con sus diferentes sobrecargas:

Código (cpp) [Seleccionar] Expandir

int compare (const string& str) const noexcept;
int compare (size_t pos, size_t len, const string& str) const;
int compare (size_t pos, size_t len, const string& str, size_t subpos, size_t sublen) const;
int compare (const char* s) const;
int compare (size_t pos, size_t len, const char* s) const;
int compare (size_t pos, size_t len, const char* s, size_t n) const;

Las que te interesaría son:

Código (cpp) [Seleccionar] Expandir

int compare (const char* s) const;
int compare (size_t pos, size_t len, const char* s) const;
int compare (size_t pos, size_t len, const char* s, size_t n) const;

Argumentos (Copiado de la página de antes):

Código [Seleccionar] Expandir

str
Another string object, used entirely (or partially) as the comparing string.
pos
Position of the first character in the compared string.
If this is greater than the string length, it throws out_of_range.
Note: The first character is denoted by a value of 0 (not 1).
len
Length of compared string (if the string is shorter, as many characters as possible).
A value of string::npos indicates all characters until the end of the string.
subpos, sublen
Same as pos and len above, but for the comparing string.
s
Pointer to an array of characters.
If argument n is specified (4), the first n characters in the array are used as the comparing string.
Otherwise (3), a null-terminated sequence is expected: the length of the sequence with the characters to use as comparing string is determined by the first occurrence of a null character.
n
Number of characters to compare.

Si, está mal declarada. Cuando declaras un array al estilo C, no puedes usar variables para delimitar el tamaño. En todo caso, tendrías que hacer esto:

Código (cpp) [Seleccionar] Expandir

char *PalabraAdivinarChar = new char[PalabraAdivinar.size()];

Lo segundo, es que no puedes hacer esta asignación (no puedes asignar a un puntero char un objeto string):

Código (cpp) [Seleccionar] Expandir

PalabraAdivinarChar = PalabraAdivinar;

Tendrías que hacer esto:

Código (cpp) [Seleccionar] Expandir

const char *PalabraAdivinarChar = PalabraAdivinar.c_str();

Date cuenta de que no he creado un array (sería inútil), sino un puntero a una cadena.

Y lo tercero y último. Puedes comparar cadenas sin tener que usar esa función. En vez de eso, usa el método compare, de la clase std::string:

y = PalabraAdivinar.compare(Respuesta);

Si y vale 0, entonces las cadenas son iguales, y si es distinto de 0, es que no son iguales. Para ser más exacto, mira esta página:

http://www.cplusplus.com/reference/string/string/compare/

Lo que delimita el tamaño de una cadena de caracteres es precisamente el carácter nulo. Si no hubiera un carácter nulo, entonces no sabríamos cual es el tamaño de la cadena. Entonces, cuando un objeto de tipo std::string toma los datos, lo hace hasta que encuentra un carácter nulo (repito, no hay otra forma segura de hacerlo). Lo único que puedes hacer es saber a ciencia cierta el tamaño de la cadena (el tamaño podría estar almacenado en una variable, por ejemplo). Una vez sabido esto, podrías reemplazar todos los caracteres nulos por otro carácter a tu elección:

Código (cpp) [Seleccionar] Expandir

std::string cString;
char *lpbyData = "aisjiajisfj\0buenas";
size_t nNumCharacters = 19; // No contamos el carácter nulo del final

for(size_t i = 0; i < nNumCharacters; i++ {
   if(lpbyData[i] == '\0')
       lpbyData[i] = '~'; // Pon el carácter de tu elección
}

cString = lpbyData;

Pero si te acabo de mostrar como validad que es un entero lo introducido :P

Esta es la secuencia:

1º- Mostramos el mensaje que nos pide el número
2º- Comprobamos que no hay errores de datos (es la parte del if)
    2.1º- En caso de error, limpiamos el buffer
3º- Pedimos datos, y empezamos el ciclo de nuevo si ha habido algún error (la condición del while)

Para comprender mejor como funciona la introducción de datos, te paso un tema mío donde lo explico con un diagrama de flujo:

http://foro.elhacker.net/programacion_cc/aporte_diagrama_de_flujo_del_operador_stdcin_stdistream-t443774.0.html

Cuando haces esto 'cin >> NumeroLetras;', siendo NumeroLetras un entero, directamente se guarda como un entero, es decir, ya es un número (no necesitas comprobar nada). Lo que tendrías que comprobar es si a la hora de introducir el número, se ha introducido correctamente. Eso se puede hacer (después de 'cin >> NumeroLetras;') viendo si std::cin.fail() retorna true o false. Si retorna true, entonces el número introducido no era correcto (se han introducido decimales, o caracteres, o el número es demasiado grande o pequeño). Si retorna false, eso significa que no ha habido ningún error.

NOTA: Si ha habido un error, tienes que limpiar el buffer que maneja std::cin. Esto lo puedes hacer así:

Código (cpp) [Seleccionar] Expandir

if(std::cin.fail()) {
   std::cin.clear();
   /*Comunicas que ya has verificado los errores. A partir de esta linea es como si no
   hubieran ocurrido, aunque en un futuro es posible que ocurran mas*/

   std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');

   /*Si el parametro vale exactamente std::numeric_limits<std::streamsize>::max(),
   entonces se ignora todo hasta el caracter fin de línea*/
}

En primer lugar, cuando llamas a la función ValidarNumeroIngresado(NumeroLetras), lo que haces es comprobar que el primer carácter sea un dígito. No compruebas que toda la cadena sea un número. Lo segundo, que para convertir la cadena en un entero, es mejor usar la función strtol, pues si hay algún error, será más previsible. En tercer lugar, ¿por qué no pides directamente un entero?

Código (cpp) [Seleccionar] Expandir

do {
   std::cout << "N\243mero de letras de la palabra: ";

   if(std::cin.fail()) { // Comprobamos si hay errores de entrada
       std::cin.clear();
       std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n'); // Limpiamos el buffer manejado por la clase std::cin
   }

   std::cin >> nNumLetters;
} while(std::cin.fail());

La variable nNumLetters es de tipo int

Te aconsejo mirar el tema que publiqué hace poco sobre el funcionamiento del operador std::cin>> para una mejor comprensión del código.

http://foro.elhacker.net/programacion_cc/aporte_diagrama_de_flujo_del_operador_stdcin_stdistream-t443774.0.html

Cuidado con:

Código (cpp) [Seleccionar] Expandir

lpszWideMessage = new wchar_t[uMessageSize * sizeof(wchar_t)];

El sizeof no se necesita para ese caso. Ahí estás creando una cadena del doble de tamaño.
Y hay que poner caracter nulo.

Código (cpp) [Seleccionar] Expandir

lpszWideMessage = new wchar_t[uMessageSize + 1];
for(size_t i = 0; i < uMessageSize; i++)
    lpszWideMessage[i] = (wchar_t)lpszMessage[i];
lpszWideMessage[uMessageSize] = '\0';

Es cierto lo del sizeof... Que despiste tengo encima XD. También tengo que reafirmar lo del carácter nulo :S Siento los errores

El no quiere recibir una cadena... quiere recibir un carácter. Scanf no es malo para los string, solamente tienes que tener cuidado de que no recoge la línea entera, sino una palabra (las palabras están delimitadas por espacios)