CODEWITHSUNDEEP
c++qtsystem-information
DenverCoder21
DenverCoder21

Reputation: 887

Qt check if current process is 32 or 64 bit

I have a 32bit and a 64bit version of my application and need to do something special in case it's the 32bit version running on 64bit Windows. I'd like to avoid platform specific calls and instead use Qt or boost. For Qt I found Q_PROCESSOR_X86_32 besides Q_OS_WIN64 and it seems this is exactly what I need. But it doesn't work:

#include <QtGlobal>

#ifdef Q_PROCESSOR_X86_64
  std::cout << "64 Bit App" << std::endl;
#endif

#ifdef Q_PROCESSOR_X86_32
  std::cout << "32 Bit App" << std::endl;
#endif

This puts out nothing when running the 32 bit App on my 64 bit Windows 7. Do I misunderstand the documentation of these global declarations?

Since there's some confusion: This is not about detecting the OS the app is currently running on, it's about detecting the "bitness" of the app itself.

Upvotes: 3

Views: 5708

Answers (5)

Burak Arslan
Burak Arslan

Reputation: 8001

You can use Q_PROCESSOR_WORDSIZE (or here). I'm surprised it's not documented because it's not in a private header (QtGlobal) and is quite handy.

It could be more preferable for some use cases because it doesn't depend on processor architecture. (e.g. it's defined the same way for x86_64 as well as arm64 and many others)

Example:

#include <QtGlobal>
#include <QDebug>

int main() {
#if Q_PROCESSOR_WORDSIZE == 4
    qDebug() << "32-bit executable";
#elif Q_PROCESSOR_WORDSIZE == 8
    qDebug() << "64-bit executable";
#else
    qDebug() << "Processor with unexpected word size";
#endif
}

or even better:

int main() {
    qDebug() << QStringLiteral("%1-bit executable").arg(Q_PROCESSOR_WORDSIZE * 8);
}

Upvotes: 4

Murphy
Murphy

Reputation: 3999

Take a look at QSysInfo::currentCpuArchitecture(): it will return a string containing "64" in it when running on a 64-bit host. Similarly, QSysInfo::buildCpuArchitecture() will return such string when compiled on a 64-bit host:

bool isHost64Bit() {
  static bool h = QSysInfo::currentCpuArchitecture().contains(QLatin1String("64"));
  return h;
}
bool isBuild64Bit() {
  static bool b = QSysInfo::buildCpuArchitecture().contains(QLatin1String("64"));
  return b;
}

Then, the condition you want to detect is:

bool is32BuildOn64Host() { return !isBuild64Bit() && isHost64Bit(); }

This should be portable to all architectures that support running 32-bit code on a 64-bit host.

Upvotes: 4

Eric Chiang
Eric Chiang

Reputation: 56

You can use GetNativeSystemInfo (see below) to determine the OS's version. As other already mentioned, the App's version is determined at the compile-time. 

_SYSTEM_INFO sysinfo;
GetNativeSystemInfo(&sysinfo);
if (sysinfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL)
{
     //this is a 32-bit OS
}
if (sysinfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
{
     //this is a 64-bit OS
}

Upvotes: 1

Adriano Repetti
Adriano Repetti

Reputation: 67090

Preprocessor directives are evaluated at compile-time. What you want to do is to compile for 32 bit and at run-time check if you're running on a 64 bit system (note that your process will be 32 bit):

#ifdef Q_PROCESSOR_X86_32
  std::cout << "32 Bit App" << std::endl;

  BOOL bIsWow64 = FALSE;
  if (IsWow64Process(GetCurrentProcess(), &bIsWow64) && bIsWow64)
      std::cout << "Running on 64 Bit OS" << std::endl;
#endif

That example is Windows specific. There is not a portable way to do it, on Linux you may use run system("getconf LONG_BIT") or system("uname -m") and check its output.

Upvotes: 1

Zbynek Vyskovsky - kvr000
Zbynek Vyskovsky - kvr000

Reputation: 18825

The correct name is Q_PROCESSOR_X86_32 or Q_PROCESSOR_X86_64.

However if it happens your application runs on ARM in future this will not work. Rather consider checking sizeof(void *) or QT_POINTER_SIZE for example.

Additionally note that on Windows the GUI applications usually can't output to stdout so it may work but doesn't show anything. Use eithrr debugger or message box or output to some dummy file instead.

Upvotes: 0

Related Questions