Mensajes

Todo lo que tienes hecho debe estar dentro del if(carácter !='\n'...
Cómo lo haces fuera, tu contador también cuenta esos caracteres y como lo usas para presentarlos en pantalla te devuelve lo que hay más allá de tus datos.

Para compilar para diferentes S.O. pásate por aquí:
https://stackoverflow.com/questions/6649936/c-compiling-on-windows-and-linux-ifdef-switch

Para controlar el terminal en Linux por aquí:
https://www.google.es/search?q=termios&oq=termios&aqs=chrome..69i57.953j0j7&sourceid=chrome&ie=UTF-8
Y un ejemplo del uso de termios para realizar getche y getch de conio: https://github.com/billroy/bitlash/blob/master/src/conio.h

Vas muy rápido. Ya haces uso de programación visual y aún no dominas el lenguaje. Por ahora, y de verdad te será mucho más fácil, sí solo trabajas en modo texto. Aprende bien los fundamentos, después ya podrás combinarlo con el s.o. de tu elección y con el entorno gráfico que más te guste.

En este punto, para aprender esto, deberías estar con algo tan sencillo como:

Código (c) [Seleccionar] Expandir

#include <stdio.h>

Int devuelve_5() {
    return 5;
}

int main() {
    int num = devuelve_5();
    printf("num = %d", num);

    return 0;
}

Los includes sobran en el ayoub.h ya que no haces uso de ninguna función de ellas.
Implementación.c sobra, el ejercicio te pide el main y justo debajo, en el mismo archivo, la implementación de la función.
La firma de la declaración y de la definición de la función deben coincidir. Deben devolver el mismo tipo de dato y los argumentos deben ser del mismo tipo.
La función debe devolver una cadena, por lo que la declaración que hay en la cabecera debería ser char* y no void como tipo de dato devuelto por la función.
Si quieres una constante definida en la cabecera usa la palabra clave const. En main deberás declararla como extern.
strcpy còpia al principio de la cadena destino, lo que necesitas es concatenar cadenas y se hace con strcat.
El enunciado dice que debes separar con espacios las palabras pero al adquirir espacio con malloc no tienes en cuenta los espacios.
De igual forma tampoco los incluyes al formar la cadena.

¿Qué llevas hecho?
No te vamos a escribir todo desde cero, te resolveremos dudas puntuales o te lo explicaremos hasta que lo entiendas (a partir de lo que veamos en donde fallas).

Debería generar antes de la llamada una variable vf::Vector con los datos y dársela como argumento a la función. Creo que así podría sortear ese fallo.

No es que sepa de C++, pero parece ser que espera una variable de sf::Vector en vez de solo la generación in situ para tomar la referencia.

No, en verdad no. Es más, es muy provechoso usar todos los recursos que te da el sistema. Para hacer el código multiplataforma ya está la compilación condicional, con el preprocesador.

B0 es la clave elegida por el diseñador, podría haber elegido cualquier otra.
Para veas como fue:
Lo primero fue contar los elementos en gProtectString3 y ver que eran los mismos más uno que el tamaño de la cadena que hay en el comentario, muemu.pl. Sabiendo esto podía decir que el los bytes eran la cadena codificada y B0 tenía que ser la codificación a '\0', que es 0 (o 00 si se miran los dos nibbles).
Después me fijé si había repeticiones: m y u se repiten y tienen los mismos bytes codificados, por tanto la codificación es byte a byte y no tiene en cuenta los demás como hace base64.
Tenía que encontrar ahora como se transformaba 0 a B0. Así que busqué una tabla ASCII en Google, ahora sabiendo como era cada carácter en esa notación podría sacar la fórmula usada para la conversión.
Cotejando el byte codificado y el de la tabla me di cuenta que solo cambiaba el nibble de más peso, el otro permanecía igual, por lo que solo debía concentrarme en ese.
A lo fácil. Probé de sumar B al primer nibble, pero no daba el resultado esperado. Así que probé sumar 5 al nibble codificado para ver si me llevaba al nibble del carácter original, tampoco.
Visto que no llegaba a ningún sitio transcribí tanto los nibbles de los caracteres como los bytes codificados a binario y los puse lado a lado y esta es la tabla que conseguí (sólo nibble de más peso):

Código [Seleccionar] Expandir

CAR     ASCII    CODIFICADO
m   : 6 (0110)    D (1101)
u   : 7 (0111)    C (1100)
e   : 6 (0110)    D (1101)
.   : 2 (0010)    9 (1001)
p   : 7 (0111)    C (1100)
l   : 6 (0110)    D (1101)
'\0': 0 (0000)    B (1011)

Un rápido vistazo se puede ver que el primer bit, el tercero y el cuarto se invierten mientras que el segundo sigue igual. La operación que hacer que un bit varíe, dentro de un grupo, es el XOR, y para que varíe el primer, el tercero y el cuarto debe el número a aplicar es el 1011 en binario o B en hexadecimal. Como el nibble de menos peso no varía se lleva XOR a 0 para ése, así que el byte entero a aplicar para la operación a todo el caracter codificado es B0.

Con un poquito de trabajo a nivel de bits he conseguido descubrir que el primer nibble está cifrado, por así decirlo. Para deshacerlo lo que debes hacer es un xor del byte entero con 0xB0.

P.ej.
DD XOR B0 = 6D (m)
C6 XOR B0 = 76 (u)

y así.