Lo siento... Estoy acostumbrado a C++ y se me había olvidado

En caso de hacer esto, estarías perdiendo información, por lo que no podrías decodificarlo... Por cierto, para ayudarte, primero inténtalo.

Respecto a que solo lee palabras, eso es por culpa de scanf. Tienes que usar la función gets para obtener la cadena completa...

Claro, tiene todo el sentido xD. Gracias por sus respuestas

Ahh vale. Gracias!

Casi nunca miro este tema xDD. Siento no haber respondido antes. Las razones son una tontería, pero ya que C++ nos provee una estructura lógica, pues vamos a usarla... Vamos, eso pienso yo. Otra razón, aunque casi ni es razón, imaginemos que una librería que no conoce cout (? jaja), y usa cout para crear una clase, pues entonces habría un conflicto xD

Hola, muy buenas. Con el fin de investigar un poco sobre la preferencia entre operadores, hice el siguiente programa:

#include <iostream>
 
int Mostrar(const char *lpszMensaje);
 
int main() {
    //(*(int *)(&(std::cout << "Izquierda->"))) + (*(int *)(&(std::cout << "Centro->"))) * (*(int *)(&(std::cout << "Derecha->")));
    Mostrar("Izquierda->") + Mostrar("Centro->") * Mostrar("Derecha->");
 
    std::cin.get();
    return 0;
}
 
inline int Mostrar(const char *lpszMensaje) {
    std::cout << lpszMensaje;
 
    return 0;
}

Lo que yo me esperaba es que se ejecutara Mostrar("Centro->") * Mostrar("Derecha->"), y después Mostrar("Izquierda->") más el resultado anterior, ya que el operador * tiene preferencia sobre el +, pero la salida del programa ha sido la siguiente:


Es decir, que ¿en teoría se habría ejecutado primero la suma, y después el producto? No lo entiendo... Si alguien me lo pudiera explicar... Gracias!

PD.: En el compilador he puesto que no optimice el código. Comando usado:

Trabajando con MinGW-w64 desde Windows

El proceso de convertir un entero en float se llama casting. Sería así:

resultado = (float)dividendo / (float)divisor;

Antes de pasar al problema principal, te voy a dar unos cuantos consejos.

0º Usa etiquetas GeSHI!! Hará el código más vistoso y entendible y así recibirás antes la ayuda

1º No uses variables globales. Aunque estés haciendo un ejercicio, el uso de variables globales casi nunca está recomendado. En lugar de eso, podrías simplemente retornar el número:

int pedirInfo() {
        int k = 0;
 
	do {
		printf("\n\n-Ingrese un numero entero positivo cualquiera: "); scanf("%d", &k);
		if(k <= 0)//validacion del dato de entrada
		{
			printf("\a\n\t\t\tERROR: Ingrese un <numero entero positivo>\n");
		}
	} while(k <= 0);
 
        return k;
}

2º Una variable de tipo 'int' ocupa 32 bits, es decir, 32 ceros o unos. Entonces, ¿por qué la cadena ocupa 1000 bytes? Mejor que solamente ocupe 33 bytes para así optimizar (el último carácter es nulo).

char cadena[33];

3º Teniendo en cuenta el paso anterior y que la cadena empieza por el cero, el ciclo for de la línea 32 se debería ver así:

for(i = 0; i < 32; i++)

4º Hay un error en la línea 34. A la hora de comparar los elementos de la cadena, comparas lo que es la cadena en sí, no los elementos:

if(cadena[i] == '1')

5º Lo que has pretendido hacer es contar la cantidad de 'números odiosos' que has introducido por el teclado, pero si reinicias esta cantidad en cada ciclo, entonces el contar no vale de nada jaja:

int i, cantidad_de_1 = 0, cantidad_de_odiosos = 0;

Las has declarado dentro del ciclo. Solución, poner esta sentencia antes de comenzar el ciclo

6º Después de cada ciclo, yo limpiaría el el buffer stdin. Para ello, al final del ciclo añade

fflush(stdin);

Además, tienes que reiniciar el número de unos en cada ciclo:

cantidad_de_1 = 0;

Después de haber dicho todo esto (espero de no haberme olvidado nada...) ESTO NO ES LO QUE PEDÍA EL EJERCICIO XDD. Lo que pedía el ejercicio es que comprobaras cuántos números odiosos había entre 1 y el número introducido...

PD. Extra: Hay una manera mucho más óptima de realizar este ejercicio. Te dejaré como pista que el ordenador de por sí guarda los datos en binario, no hace falta convertirlos... Puedes usar los operadores &, >> y todos los demás operadores binarios...

ESPERO HABERTE SIDO DE AYUDA!!

Hola a tod@s. La cosa es que estaba experimentando con las librerías Standard 'chrono.h' y 'thread.h' de C++11, usando el compilador de VC2015 de 64 bits. El problema es que al decirle que espere un milisegundo con la función 'std::this_thread::sleep_for(std::chrono::milliseconds(1))', el programa dice que espera entre catorce y quince milisegundos.

#include <iostream>
#include <thread>
#include <chrono>
#include <windows.h>
 
int main() {
	std::chrono::high_resolution_clock::time_point cStartTime, cEndTime;
	long long lTimeElapsed;
 
	while(true) {
		cStartTime = std::chrono::high_resolution_clock::now();
		//std::this_thread::sleep_for(std::chrono::milliseconds(1));
		Sleep(1);
		cEndTime = std::chrono::high_resolution_clock::now();
 
		lTimeElapsed = std::chrono::duration_cast<std::chrono::milliseconds>(cEndTime - cStartTime).count();
 
		std::cout << "Time elapsed: " << lTimeElapsed <<  "ms" << std::endl;
	}
 
	std::cout << "\nEl programa ha terminado";
 
	std::cin.get();
	return 0;
}

Nota: La función Sleep y 'std::this_thread::sleep_for(std::chrono::milliseconds(1));' dan los mismos resultados

Aquí una captura de la salida:

Tendrías que poner en vez de 'char palabra[100]="";', 'static char palabra[100]="";'