No entiendo cuál era el objetivo final de este código. Con esa información, podríamos ayudarte mejor y con respuestas más claras.

Tienes que saber que esas operaciones  son binarias, es decir, se involucran dos "cosas". Por ejemplo, el operador = es binario puesto que necesita dos cosas: una variable a la que asignar un valor, y el dicho valor (a = b, se necesita tanto "a" como "b"). Pero te preguntarás: ¿qué pasa con la sentencia a = 5 + 1 + 3 * 5 - 7? Pues bien, esa operación, a la hora de compilar, se divide en operaciones de dos en dos. Normalmente, el orden de preferencia va de izquierda a derecha, pero con el operador = va de derecha a izquierda. Vamos a expresar la sentencia que he puesto de ejemplo en operaciones binarias:

1º Está el operador =, por lo que es de derecha a izquierda. Primero tenemos que procesar 5 + 1 + 3 * 5 - 7.
2º El operador * tiene preferencia sobre los operadores + y -, por lo que en primer lugar se procesa 3 * 5. Una vez procesado, quedaría así:
5 + 1 + 15 - 7
3º Como entre los operadores + y - no hay preferencia, la expresión se evalua de izquierda a derecha:
>> 6 + 15 - 7
>> 21 - 7
>> 14
4º La expresión final quedaría así:
a = 14
Por tanto, a la variable a se le asigna el valor 14.

Para saber más sobre la preferencia entre operadores, consulta : esta página

Una vez sabido esto, puedes analizar la expresión que tienes en tu while

Antes de nada, quiero dejar una nota aclaratoria. El sistema operativo tiene un buffer (espacio de memoria) para los valores de entrada de una consola. En C y C++, podemos acceder indirectamente a este buffer como si de un archivo se tratara.

Definición de stdin según cplusplus:

FILE * stdin;

(Puede diferir entre compiladores)

Para más información, consulta: esta página
__________________________________________

Aunque la sentencia "a=c=getchar()" esté dentro de la condición del while, la igualación se hace igual. Es como si hicieras:

a = c= getchar();
while(a == '1') { // a y c tienen el mismo valor, puedes poner la que quieras
    a = c = getchar();
}

Que a su vez, equivale a

a = getchar();
c = a;
while(a == '1') { // a y c tienen el mismo valor, puedes poner la que quieras
    a = getchar();
    c = a;
}

Vamos a analizar este segundo código:

-Primero, tienes que saber que en las operaciones de igualdad se ejecutan de derecha a izquierda, por lo que primero se ejecuta la función getchar() y posteriormente el valor de retorno se le asigna a la variable 'a'.
Cuando ejecutas esta función, si el buffer que maneja stdin no tiene datos (ese buffer lo guarda el sistema operativo, no tenemos acceso a el directamente) entonces el programa se pausa y espera a que el usuario introduzca datos. Cuando introducimos datos, al final tenemos que pulsar enter, y ese enter se guarda (es decir, se guarda el salto de línea). Por ejemplo, si introducimos un '1' y le damos a enter, se va a guardar la siguiente secuencia de bytes: 0x31 (equivale a '1') y 0x0A (equivale a 'salto de línea' o '\n'). Entonces, la función getchar va a tomar el primer byte que se encuentra. En este caso, va a ser el 0x31. Los datos obtenidos se borran del buffer de stdin, por lo que ahora este buffer tiene solamente el salto de línea (0x0A)

-Segundo, igualamos a la variable c el valor de a, es decir, a partir de esa sentencia, a y c tienen exactamente el mismo valor (si seguimos el ejemplo anterior, a y c valen '1').

-Tercero, en el while, comprobamos si el usuario ha introducido un '1'. De ser así, el while ejecutaría el bloque de sentencias del while. Como en este ejemplo sí que hemos introducido un '1', entonces el while se ejecutará. Al ejecutarse el while, llamamos a la función getchar() de nuevo. Como ya he dicho, getchar toma datos del buffer de stdin. En este caso, este buffer SI tiene datos, por lo que el programa NO se va a pausar de nuevo. Entonces, los datos que hay son un salto de línea (como vimos en el paso 1), por lo que getchar toma ese salto de línea, borra ese dato del buffer de stdin y se lo asigna a la variable 'a'. Entonces, ahora la variable 'a' tiene el valor de un salto de línea.

-Cuarto, le asignamos el valor de 'a' a la variable 'c'.

Por todo esto, las variables 'a' y 'c' equivalen a un salto de línea cuando introduces un '1'.

Lo que hace getchar, como dice su nombre, es tomar un byte del buffer stdin. Cuando tu introduces un carácter en la consola, se guarda ese carácter Y un salto de línea. Entonces, getchar toma ese carácter introducido y deja el salto de línea sin eliminar. Entonces, esta es la secuencia:

1º Introducimos un 1 por consola y le damos a enter para seguir. En el buffer de stdin se guarda la siguiente secuencia: 0x310A (31 es '1' en hexadecimal y 0A es un salto de línea).
2º Getchar toma el primer byte de esa secuencia (31).
3º Como La condición 31 == '1' se cumple, entonces el la sentencia while se ejecuta (en este caso, la sentencia es nula)
4º Comparamos de nuevo. Como en el buffer de stdin aún hay datos, entonces el programa no se pausa, sino que toma datos de esa secuencia. En este caso, getchar retorna 0x0A, lo que es un salto de línea. Como 0x0A es distinto de '1', entonces el while ya no se ejecuta y las variables a y c se quedan con el valor de salto de línea (0x0A).

Conclusiones:
-Si introducimos un '1', entonces las variables a y c guardarán un salto de línea.
-Si ponemos cualquier otro carácter, las variables a y c guardarán ese carácter y el buffer de stdin se quedará con un elemento por leer.

Lo que yo haría es esto:

int digitomagico(int numero) {
    int suma = 10; // Para poder entrar en el bucle
 
    while(suma >= 10) {
        suma = 0; // Tenemos que resetear la suma en cada iteracion
 
        while (numero != 0){ // Calculamos la suma de todas las cifras
            suma += numero%10;
            numero /= 10;
        }
 
        numero = suma; // Igualamos el numero pues lo usaremos para comprobar en la siguiente iteracion
    }
 
    return numero;
}

Está comprobado con el ejemplo que pones

En el log de code::blocks (pulsando F2), ¿que aparece?

¿Has probado usando este código?

#include <iostream>
 
int main() {
    std::cout << "Hello World" << std::endl;
 
    return 0;
}

Necesitamos más datos para poder ayudarte

Lástima que no haya prácticamente nada en español... Es cierto que podría leer la referencia (lo nuevo). Probablemente es lo que haga! Muchas gracias por sus respuestas

Primero, no deberías usar las versiones de OpenGL antiguas. Lo segundo: lo primero que se ha de hacer es trasladar y luego rotar. No sé muy bien como iba en las versiones anteriores a la 3, pero lo que tendrías que hacer es lo siguiente:

projectionMatrix*(rotationMatrix*(translateMatrix*GL_MODELVIEW_MATRIX))

Cuando traslades el objeto, ten en cuenta el ángulo

if(wKeyIsPressed) {
    position.z += K * cos(fAngleY); // La K es una constante
    position.x -= K * sin(fAngleY);
}

Y así con todas las teclas

Corregidme si me equivoco, pues suelo tratar con temas de renderizado y todo eso, no estoy acostumbrado a trasladar, rotar, ni cámaras... (si, suena estúpido, pero es así )

Hola. Estoy buscando un libro en español para aprender C++11. No sé si existe en español. En caso de que no haya, ¿cuál me recomiendan en inglés? Gracias de antemano.

Aunque se lo hayas preguntado a avesudra, te doy mi opinión. Para usar OpenGL, te aconsejo que uses GLFW. En mi experiencia, he encontrado más tutoriales sobre GLFW que sobre FreeGLUT. Por ejemplo, mi tutorial favorito de entre todos los que he encontrado es: http://learnopengl.com/. La información está muy clara y trata tanto los temas más sencillos como los más complejos con total soltura y bien explicado. Otros tutoriales son:

• https://open.gl/
• http://www.opengl-tutorial.org/
• http://www.mbsoftworks.sk/index.php?page=tutorials&series=1 (Este se basa en la API de Windows, no en GLFW)

Yo no he encontrado ningún tutorial sobre OpenGL 3.3 en adelante en español. NO APRENDAS VERSIONES INFERIORES A ESTA. OpenGL sufrió un gran cambio a partir de la versión 3, donde se fueron descatalogando la mayoría de las funcionalidades, por lo que todo lo que aprendieses de las versiones anteriores a la 3, no te serviría de nada al pegar el salto.

Yo he probado el código usando "std::this_thread::sleep_for(std::chrono::milliseconds(1));", y sucede algo curioso: algunas veces marca un milisegundo, pero otras veces marca entre esos 14 y 15 milisegundos... Es extraño