ce n'était qu'un exemple(les HWND)

//fichier.c
int variable_global;
//...

//fichier.h
extern int variable_global;
//...

//fichier2.c
#include "fichier.h" // inclut également « extern int variable_global; »
//...

//fichier3.c
#include "fichier.h" // idem ...
//...


//...

la déclaration de tes variables devrait ce trouver dans main.c et non dans main.h. on ne devrait pas voir ces variables dans ton fichier d'entête, tout ce qu'on pourrait y voir pourrait être, par exemple:

// main.h

//...
extern HWND hMainWnd;
extern HWND hAboutWnd;
extern HWND hPitchWnd;
extern HWND hEchoWnd;
extern HWND hAdvancedVolumeWnd;
//etc.

si ces variables ne sont utilisés que dans main.c alors qu'ils restent dans main.c, c'est une très très mauvaise habitude de déclarer ses variables dans un fichier d'entête ... c'est souvent source de problème

en C++, les « :: » ce sont les opérateurs de portés, exemple:

class Player
{
public:
  Player()
  {
    // ...
  }
  ~Player()
  {
    // ...
  }
  int PlaySound() // existe aussi dans l'api windows
  {
    // fait appel a une référence externe(api windows)
    return ::PlaySound();
  }
  // ...
};

#include <stdio.h> // getchar()/puts()
#include <stdlib.h> // system()

#ifdef _WIN32
# define _CLEAR_SCREEN() system("cls")
#else /* on assume que c'est linux */
# define _CLEAR_SCREEN() system("clear")
#endif

#define _PAUSE()\
  do{\
    puts("\nPress Enter to continue...");\
    getchar();\
  }while(0)

int main()
{
  puts("bonjour");
  _PAUSE();

  _CLEAR_SCREEN();
  puts("fin du programme");

  _PAUSE();
  return 0;
}

#include <windows.h> // ...
#include <iostream> // std::cout
#include <string> // std::string
#include <sstream> // std::stringstream

// PCSTR >> const char*
std::string GetValueData(HKEY hkTopKey, PCSTR pSubKey, PCSTR pValueName)
{
    HKEY hkKey;
    DWORD dwType;
    DWORD dwDataSize = cstMaxRegLength;
    BYTE* pData;
    std::string strBuffer;
    std::stringstream strStream;

    if (RegOpenKeyExA(hkTopKey, pSubKey, 0, KEY_READ, &hkKey) == ERROR_SUCCESS)
    {
        pData = new BYTE[cstMaxRegLength + 1];

        if (RegQueryValueExA(hkKey, pValueName, NULL, &dwType, pData, &dwDataSize) == ERROR_SUCCESS)
        {
            switch (dwType)
            {
                case REG_BINARY:
                    strStream << (UINT)pData[0] << (CHAR)'.' <<\
                                 (UINT)pData[1] << (CHAR)'.' <<\
                                 (UINT)pData[2] << (CHAR)'.' <<\
                                 (UINT)pData[3];
                    break;

                case REG_DWORD:
                    strStream << *(DWORD*)pData;
                    break;

                default: dwDataSize = 0;
                    // !break

                case REG_EXPAND_SZ:
                case REG_MULTI_SZ:
                case REG_SZ:
                    pData[dwDataSize] = '\0'; // simple précaution
                    strStream << (PCSTR)pData;
                    break;
            }
            strBuffer = strStream.str();
        }
        delete [] pData; // libère la mémoire
        RegCloseKey(hkKey);
    }
    return strBuffer;
}

int main()
{
    std::string retval = GetValueData(..., ..., ...);

    std::cout << retval << std::endl;
    return 0;
}

dernière petite chose

BOOL hServiceStatus;
BOOL hControlService;
BOOL hStartServices;

« h » désigne un « HANDLE », pas un BOOL

BOOL bServiceStatus;
BOOL bControlService;
BOOL bStartServices;
// serait plus ... approprié

  // ton code
  hServiceStatus = QueryServiceStatus( ... );

quand on lit ca, on ce dit, ah! QueryServiceStatus() retourne un « HANDLE », mais non! c'est faux! QueryServiceStatus() retourne un « BOOL » !

en passant, retire cette phrase « pas d'erreur de compilation »
je ne veux pas être méchant mais c'est ridicule puisque
« 0 error(s), 0 warning(s) » ne veut strictement _rien_ dire ...

pour la Xeme fois

#include <stdlib.h> // C
#include <cstdlib> // C++
#include <iostream.h> // BAD! sans .h << cette version est obsolète(elle existe encore pour une raison de compatibilité avec de ~vieux programmes)
#include <iostream> // GOOD

ta gestion des chaines de caractères est _Complètement_ nulle

Cl_SVR::Cl_SVR(){
    service="\0"; // c'est un char*, pas d'allocation mémoire ni rien d'autre du genre
    strcat(service,"inort"); // ca va faire !!!CABOUME!!!
    nompc="\\\\"; strcat(nompc,getenv("COMPUTERNAME")); // ca aussi!
    Status();
}//end procedure

pourquoi est-ce que tu n'utiliserais pas les basic_string hein?

#include <string>

class Cl_SVR
{
// ...
string service;
string nompc;
// ...
};

Cl_SVR::Cl_SVR() : service("inort"), nompc("\\\\")
{
    nompc += getenv("COMPUTERNAME");
    Status();
}//end procedure

Cl_SVR::Cl_SVR(const char * s,const char * pc) : service(s), nompc("\\\\")
{
    nompc += pc;
    Status();
}//end procedure

service.c_str() pour obtenir un pointeur sur la chaine

const char* c_str() const {
  return un_pointeur_sur_la_chaine;
}


etc...
etc...
etc...

void Cl_SVR::PsKill(const char * proc)
{
  //char * cmd = new (char[100]);
  char cmd[100+1]; // si tu ne veux pas libérer la mémoire alors pas de « new » !
  snprintf(cmd, 100, "pskill -t %s %s >log.txt", nompc, proc);
  //strcpy(cmd,"\0");
  //strcat(cmd,"pskill -t ");
  //strcat(cmd,nompc);
  //strcat(cmd," ");
  //strcat(cmd,proc);
  //strcat(cmd," >log.txt");
  system(cmd);
}//end function

Je suis désolé de te le dire mais ton code n'est pas bon, mais pas du tout!
Va reviser la « Gestion Des Chaînes De Caractères » !!!

si tu utilise un « char* », tu dois lui assigner/allouer de la _Mémoire_
tu ne peux pas manipuler ton pointeur, qui, pointe sur _Rien_ !

sinon, comme j'ai dit plus haut, utilise basic_string >> #include <string>
avec basic_string, pas besoin de t'occuper de la gestion de la mémoire, basic_string le fait tout seul comme un grand!

autre petite chose, pour le « status », utilise un entier quelconque pour connaître le status et non une chaine, avec un entier ca serait tellement plus simple/rapide/... et surtout, beaucoup mais beaucoup moins lourd à gérer. si tu tiens absolument a obtenir le status en « texte », ajoute une simple/petite/... fonction qui va te retourner le status(en texte)

const char* getStatusString(int nStatus)
{
  switch (nStatus)
  {
    case X: return "status X";
    case Y: return "status Y";
    // ...
    default: break;
  }
  return "unknown status";
}


...
...
...

dernière petite chose pour aujourd'hui
dans « GetValueData() » tu as oublié de libérer la mémoire alloué pour lpData

« delete [] lpData; » avant de quitter la fonction(GetValueData)

en passant:
« cout << GetValueData(hkKey,"SOFTWARE\\Microsoft\\DirectX","Version") << endl; »

ton GetValueData() retourne un pointeur sur un char* que tu as alloué
récupère la valeur de GetValueData() et _ensuite_, affiche la

char* ptr = GetValueData( ... );
cout << ptr << endl;
delete [] ptr;

sinon tu vas avoir des fuites de mémoire _partout_ !

dans ton GetValueData(), petit truc:

// ...
char * rValue = new char[cstMaxRegLength];
rValue[0] = '\0'; // place ca ici(valeur par défaut, si on veut), comme ca tu sauve beaucoup de « else/default/... »
// ..

la répétition de code c'est pas très bon ...