Euclid gcd

Ok I got a program to return a GCD but the math is not correct I believe because it is returning a number now but some of the GCD it returns is not the correct one...

Code:

---


#include <windows.h>
#include <stdio.h>
#include <process.h>
#include <ctime>
#include <iostream>
#include <cstdlib>
#include <stdlib.h>
using namespace std;

//DECLARE GLOBAL VARIABLES

int firstRandomNumber = 0;
int secondRandomNumber = 0;

//FUNCTION TO TEST IF secondrandomNumberCheck EQUALS ZERO AND TO RETURN firstrandomNumberCheck AND ANC IF IT DOES
//int abc(int firstrandomNumberCheck, int secondrandomNumberCheck)
//{
        //IF STATEMENT TO DETERMIN IF THE SECOND NUMBER IS 0
        //if (secondrandomNumberCheck == 0)
    //return firstrandomNumberCheck;

  //return abc(secondrandomNumberCheck, firstrandomNumberCheck % secondrandomNumberCheck);
//}

//BEGIN RANDOM NUMBER TEST FUNCTION
void randomNumberCheck()
{
        firstRandomNumber = 1 + rand()% 100; 
        secondRandomNumber = 1 + rand()% 100;
       


        //SHOW OUTPUT
    cout << " The first random number is " << firstRandomNumber << "." << endl;
        cout << "          The second random number is " << secondRandomNumber << "." << endl;



}

//change
int gcd (int firstRandomNumber, int secondRandomNumber)
{
       
        //change
        //if (x==0)
        if (secondRandomNumber==0)
        {
                //change
                //return y;
                return firstRandomNumber;
        }
        else
        {
                int x = (secondRandomNumber, firstRandomNumber % secondRandomNumber);
                return x;
               
        }
        //return returngcd;
}


//CREATE AN UNSIGNED COUNTER AND HANDLE
unsigned counter;
HANDLE hMutex;

//UNSIGNED CALL
unsigned __stdcall SecondThreadFunc(void* pArguments)
{
        //int firstRandomNumber;
        //int secondRandomNumber;
       
        //SHOW OUTPUT
        cout << "In second thread....." << endl;
        //printf( "In second thread..." );
        DWORD checkWaitResultTest;

        //SHOW THE COUNTER BEING LESS THAN 10
        while (counter < 10)

        {
                //REQUEST OWNERSHIP WILL NEED TO BE PERFORMED
                checkWaitResultTest = WaitForSingleObject(hMutex, 5000L);

                //SWITCH STATEMENT TO CHECK RESULTSW
                switch (checkWaitResultTest)

                {
                        // The thread got mutex ownership.
                        case WAIT_OBJECT_0:
                        __try

                        {
                                //IF STATEMENT IF THERE IS A REMAINDER
                                if (counter % 2)

                                {
                                        counter++;
                                        //SHOW OUTPUT
                                        cout << "Thread #2 " ;
                                       

                                        //ENTER RANDOM NUMBER FUNCTION
                                        //randomNumberCheck();

                                        //SHOW OUTPUT OF THE THREAD TWO COUNTER
                                        printf ("Thread Two Counter is %d\n", counter);

                                        //CALL EUCLAID
                                        //Changed
                                       
                                        printf ("Call Euclid\n");
                                        //changed
                                        cout << firstRandomNumber << secondRandomNumber;
                                       
                               
                                        int x = gcd(secondRandomNumber, firstRandomNumber);
                                        //gcd(firstRandomNumber, secondRandomNumber);
                                        //changed
                                       
                                        //cout << firstRandomNumber << secondRandomNumber;

                                        //OUTPUT OF EUCLAID
                                        //When I put in gcd(30,40)) or any other number it returns the values and it works but
                                        //when I use gcd(firstRandomNumber,secondRandomNumber it keeps returning 0 so I believe
                                        //the values are not passing in correctly
                                        //changed
                                        printf("Greatest common divisior (GCD) is %d\n", gcd(secondRandomNumber, firstRandomNumber));
                                        //printf("Greatest common divisior (GCD) is %d\n", gcd(secondRandomNumber, firstRandomNumber));
                                        //printf("Greatest common divisior (GCD) is ", gcd, "\n\n");

                                }
                        }

                        __finally

                        {
                                //RELEASE THE MUTEX
                                if (! ReleaseMutex(hMutex))

                                {
                                       
                                }

                                break;
                        }
                        // TIME OUT IN THE MUTEX
                        case WAIT_TIMEOUT:

                        {
                                // MUTEX ABANDONED
                                return false;
                        }

                        case WAIT_ABANDONED:
                        {
                                return false;
                        }
                }
        }
        _endthreadex( 0 );
        return 0;
}

//MAIN FUNCTION
int main()

{
        srand((unsigned int)time(NULL));
        //srand (5);

        //DECLARE VARIABLES
        HANDLE hThread;
        unsigned threadID;
        counter = 0;
        hMutex = CreateMutex(NULL, FALSE, (LPCWSTR) "MutexToProtectDatabase");

        //IF STATEMENT TO CHECK IF HMUTEX IS NULL AND ERROR IF IT IS
        if (hMutex == NULL)
        {
                // Check for error.
        }

        //SHOW OUTPUT
        printf ("Start program by creating second thread\n\n");

        // SECOND THREAD WILL NEED TO BE CREATED
        hThread = (HANDLE)_beginthreadex( NULL, 0, &SecondThreadFunc, NULL, 0, &threadID );
        DWORD dwWaitResult;

        //WHILE STATEMENT TO MAKE SURE COUNTER IS UNDER 10
        while (counter < 10)
        {
                // OWNERSHIP OF MUTEX
                dwWaitResult = WaitForSingleObject(hMutex, 5000L);

                //SWITCH STATEMENT FOR THE DWWAIT
                switch (dwWaitResult)
                {
                        //THREAD NOW HAS OWNERSHIP
                        case WAIT_OBJECT_0:
                        __try
                        {
                                //IF STATEMENT IF THERE IS NOT A REMAINDER
                                if (!(counter % 2))
                                {
                                        //SHOW OUTPUT
                                       
                                        cout << "Thread #1 " ;
                                        counter++;

                                        //ENTER ABC FUNCTION
                                        //abc(firstrandomNumberCheck,secondrandomNumberCheck);

                                       
                                        randomNumberCheck();
                                       
                                       

                                        //SHOW OUTPUT
                                        printf ( "Primary Thread Counter is %d\n", counter );
                                       
                                }
                        }

                        __finally

                        {
                                //MUTEX WILL NEED OWNERSHIP
                                if (! ReleaseMutex(hMutex))
                                {
                                        // ERROR WILL OCCUR
                                }

                                break;
                        }

                        // MUTEX TIMES OUT
                        case WAIT_TIMEOUT:
                        {
                                //OWNERSHIP OF ABANDONED MUTEX
                                return false;
                        }

                        case WAIT_ABANDONED:

                        {
                                return false;
                        }
                }
        }

        //ENTER FUNCTION
        WaitForSingleObject( hThread, INFINITE );

        //SHOW OUTPUT
        printf( "Counter should be 10.\nCounter is currently %d\n", counter);

        // DESTROY THIS THREAD
        CloseHandle( hThread );

        return 0;
}

---

disregard I figured it out