XOR in assembly language linked with C++

The problem is related to the function of encrypting a string with a gamma sequence.

Function call:

cout << "\ncipher with code: ";
    for (register int i = 0; i < str.length(); i++) {
        str[i] = fun_cipher_gamma(str[i], gamma[i]);
        cout << str[i];
    }
cout << endl;

The function itself:

char fun_cipher_gamma(register char simbol, register char gamma)
{
    char result = ' ';
    funct();
    return result;
}

Assembly code:

.MODEL FLAT, C
.STACK 256
.DATA

.CODE

	EXTRN gamma : BYTE
	EXTRN simbol : BYTE
	EXTRN result : BYTE

PUBLIC funct
funct PROC far

	mov al, simbol        
    mov bl, gamma         
    xor al, bl            
    mov result, al        
    retn

funct ENDP
END

Using the debugger I realized that the assembly language function doesn't return result, but how to fix it I don't understand.
I assume I need to use push, but I'm not sure and I'm lost, since my assembly language skills are almost non-existent

This function worked successfully in C++, and I need to redo its logic in assembly language:

return btowc(simbol) ^ btowc(gamma);

UPD: In .cpp I`ve added these externs:

extern "C" char funct(void);
extern "C" unsigned char gamma = ' ';
extern "C" unsigned char simbol = ' ';
extern "C" unsigned char result = ' ';

As @Chris Dodd mentioned, you aren't using the global variables in the assembly!
And it's better to use a calling convention instead of using global variables as parameter. It improves readability and makes it easier to understand.

extern "C" char funct(unsigned char symbol, unsigned char gamma);
char fun_cipher_gamma(unsigned char symbol, unsigned char gamma)
{
    return funct(symbol, gamma);
}

; in C calling convention:
; Caller passes Parameters via stack and all arguments are pushed to stack as dwords (4 byte)
; Callee should preserve EBX, ESI, EDI, EBP, and ESP
; and use EAX to return a value
push ebp     ; Callee should preserver old value of EBP
mov ebp, esp ; set the base pointer to stack pointer
; sub esp, 8   ; make room for 8 byte of variables (commented out because we aren't using it)

; push any other registers that you'll use HERE

; ...
; [ebp - 12] = local variable #3
; [ebp -  8] = local variable #2
; [ebp -  4] = local variable #1
; [ebp +  0] = old EBP the we pushed
; [ebp +  4] = return address
; [ebp +  8] = parameter #1
; [ebp + 12] = parameter #2
; [ebp + 16] = parameter #3
; [ebp + 20] = parameter #4
; ...

; so this means "symbol" is at [ebp + 8] and gamma is at [ebp + 12]
; [ebp +  8] = symbol
; [ebp + 12] = gamma

mov eax, [ebp +  8]
xor eax, [ebp + 12]

; pop saved registers HERE

mov esp, ebp ; restore ESP to its original value
pop ebp      ; restore EBP's value
ret

But please note that nowadays using assembly won't improve your program's performance (in fact you may lose performance), compilers write faster assembly than we.
It may be possible to write faster assembly than compiler if they aren't optimizing but as soon as you enable optimizing they'll write faster assembly than you.

MSVC19 compiled this:

char funct(unsigned char symbol, unsigned char gamma) {
    return symbol^gamma;
}

to this:

xor     cl, dl
mov     al, cl
ret     0

which uses less space while being faster than our implementation (it's using fastcall calling convention).
For more info about calling conventions: https://www.dyncall.org/docs/manual/manualse11.html