Ниже описан общий подход к тому, как собрать Windows-исполняемый .exe (приложение под Windows) из Qt/C++ проекта на macOS с использованием CMake. Сразу отмечу, что прямое «обычное» создание .exe на Mac невозможнó без специального инструментария: необходима либо кросс-компиляция (MinGW, clang для Windows и т.д.), либо запуск сборки в среде Windows (например, в виртуальной машине, Docker-контейнере с Windows, WINE для сборки и т.д.). Самый популярный вариант – установка MinGW-w64 для macOS и настройка CMake-проекта так, чтобы использовать кросс-компилятор.

Ниже шаги по порядку:

---

Шаг 1. Убедиться, что проект кроссплатформенный

1. Код и библиотеки:
   Убедитесь, что ваш код не содержит специфичных для macOS функций (например, использования Objective-C++ кода) и что все внешние зависимости доступны на Windows (или есть аналоги).

2. Qt-модули:
   Обычно Qt – кроссплатформенный фреймворк. Следите только, чтобы в CMakeLists.txt не было модулей или флагов, которые доступны исключительно на macOS.

---

Шаг 2. Установить MinGW-w64 для macOS

На macOS есть возможность поставить кросс-компилятор, который умеет собирать код под Windows. Самый популярный вариант – MinGW-w64:

bash
brew install mingw-w64

(Если Homebrew не установлен, сначала нужно установить Homebrew.)

После установки в системе будут доступны компиляторы вида:

• x86_64-w64-mingw32-gcc
• x86_64-w64-mingw32-g++ и т. д.

---

Шаг 3. Создать (или настроить) CMake toolchain-файл для сборки под Windows

Что такое toolchain-файл?

Это специальный файл CMake, в котором указываются пути к кросс-компиляторам и другие параметры окружения. Назовём его, например, toolchain-mingw.cmake.

Содержимое может выглядеть так (базовый пример):

cmake
# toolchain-mingw.cmake

set(CMAKE_SYSTEM_NAME Windows)
set(CMAKE_SYSTEM_PROCESSOR x86_64)

# Указываем, что будем использовать MinGW-w64
set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc)
set(CMAKE_CXX_COMPILER x86_64-w64-mingw32-g++)

# Устанавливаем флаги компиляции, если нужно:
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libstdc++ -static-libgcc")
set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -static-libgcc")

Обратите внимание на флаги -static-libstdc++ и -static-libgcc. Они чаще всего нужны, чтобы «вшить» системные runtime-библиотеки (libstdc++/libgcc) прямо в .exe. Это упрощает запуск на Windows-машине, где может не оказаться необходимых версий DLL.

Если требуется Qt, нужно убедиться, что у вас есть подходящие для Windows заголовки и библиотеки Qt (см. ниже раздел «Qt-библиотеки»).

---

Шаг 4. Запустить CMake c указанием toolchain-файла

Переходим в папку сборки (или создаём её):

bash
mkdir build-windows
cd build-windows

Затем вызываем CMake, указывая путь к исходникам и к файлу toolchain-mingw.cmake:

bash
cmake \
  -DCMAKE_TOOLCHAIN_FILE=../path/to/toolchain-mingw.cmake \
  -DCMAKE_BUILD_TYPE=Release \
  ../path/to/your_project

Обратите внимание, что пути (path/to/...) нужно заменить на реальные пути к вашему проекту и к файлу toolchain-mingw.cmake.

Далее запускаем сборку:

bash
cmake --build . --config Release

или

bash
make -j4

(в зависимости от используемой системы сборки).

---

Шаг 5. Найти скомпилированный .exe файл

После завершения сборки в папке build-windows (или где CMake создал папки bin/Release/Debug и т.п.) вы увидите итоговый файл с расширением .exe (например, myapp.exe).

---

Шаг 6. Подготовка Qt-библиотек (если вы используете Qt)

Если ваш проект использует Qt, то просто установить MinGW-w64 мало:

1. Нужно либо установить и собрать Qt для Windows (MinGW) непосредственно на macOS (кросс-сборка Qt – задача посложнее).
2. Либо (чаще всего проще) собирать проект непосредственно под Windows, где установлен Qt и MinGW.

Вариант «Кросс-компиляция Qt на macOS»

В этом случае придётся:

• Скачивать/собирать Qt под кросс-компилятор MinGW-w64.
• Ставить правильные пути к Qt5_DIR или Qt6_DIR в CMakeLists.txt.
• Указывать, где лежат .lib/.dll/.a файлы Qt.

Это достаточно сложный процесс и в небольших проектах чаще обходятся виртуальной машиной (или Docker-средой) с Windows + MinGW + Qt.

Вариант «Сборка в среде Windows»

Проще всего взять машину (или виртуалку) с Windows, поставить:

• Qt SDK (MinGW-версию),
• CMake,
• MinGW (идёт в составе Qt, если при установке выбрать MinGW kit).

Далее собрать проект классически:

powershell
cmake -G "MinGW Makefiles" -DCMAKE_BUILD_TYPE=Release path\to\project
mingw32-make -j4

В результате получите .exe, готовый к запуску в Windows.

---

Шаг 7. Деплой на Windows

Когда у вас есть .exe, важно убедиться, что все нужные DLL (библиотеки) лежат рядом или находятся в доступном для Windows PATH. Для Qt-приложений обычно используют windeployqt.exe (если сборка велась в Windows), которое автоматически собирает нужные Qt-библиотеки.

Если вы сделали кросс-компиляцию и динамически ссылаетесь на Qt (или другие библиотеки), то нужно вручную положить рядом соответствующие .dll файлы. Если использовалась статическая сборка (статические библиотеки Qt), то можно обойтись без DLL (но статическая сборка Qt обычно требует отдельной конфигурации).

---

Итоговый алгоритм (кратко)

1. Установить MinGW-w64 на macOS.
2. Создать toolchain-файл для CMake (с настройками под MinGW-w64).
3. Собрать проект командой cmake --build . с нужным toolchain-файлом.
4. Получить .exe в папке сборки.
5. Если используется Qt, либо кросс-компилировать Qt для Windows на macOS, либо собирать в среде Windows (чаще проще).
6. Не забыть добавить нужные DLL (или статически связать).

Таким образом, вы получите .exe, который можно будет запустить на Windows. Если проект только начинает развиваться, и нет критичной необходимости кросс-собирать на macOS, проще всего поставить Windows (на реальную машину, в виртуалку, через Boot Camp) и собирать там, используя Qt Installer (MinGW kit) или Visual Studio kit – это сильно упростит процесс.

Ниже пошаговое объяснение, как создать и где разместить toolchain-файл для кросс-компиляции под Windows с помощью MinGW-w64 на macOS. Предположим, что вы уже установили MinGW-w64 через Homebrew (brew install mingw-w64).

---

1. Где создавать toolchain-файл?

Чёткого, «обязательного» места для toolchain-файла нет. Главное — чтобы вы могли к нему обратиться из командной строки или из вашего CMakeLists.txt. На практике есть несколько распространённых вариантов:

1. В корне проекта.

   • Рядом с вашим CMakeLists.txt (например, toolchain-mingw.cmake).
   • Плюс: легко указывать путь, всё под рукой.

2. В отдельной папке (например, cmake/toolchains или toolchains).

   • Если в проекте несколько toolchain-файлов (под разные платформы), так легче организовать структуру.

3. В любом другом месте, лишь бы путь был доступен при вызове cmake.

Для начала, проще всего создать файл в корне проекта.

---

2. Как создать toolchain-файл?

1. Откройте любой текстовый редактор (Xcode, Visual Studio Code, Sublime, nano — что удобнее).

2. Создайте пустой файл и сохраните его под именем, например, toolchain-mingw.cmake.

3. Поместите туда примерно такой минимальный набор строк:

   cmake
   # toolchain-mingw.cmake
   
   # Указываем, под какую "систему" мы собираем
   set(CMAKE_SYSTEM_NAME Windows)
   set(CMAKE_SYSTEM_PROCESSOR x86_64)
   
   # Указываем MinGW-компиляторы (пути могут отличаться в зависимости от установки)
   set(CMAKE_C_COMPILER x86_64-w64-mingw32-gcc)
   set(CMAKE_CXX_COMPILER x86_64-w64-mingw32-g++)
   
   # Рекомендуется статически линковать runtime-библиотеки:
   set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -static-libgcc")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libstdc++ -static-libgcc")

   Обратите внимание, что имена компиляторов (x86_64-w64-mingw32-gcc, x86_64-w64-mingw32-g++) должны совпадать с тем, что у вас установилось через Homebrew. Если вы не уверены, можно в терминале набрать which x86_64-w64-mingw32-g++ и посмотреть, где лежит исполняемый файл.

4. Сохраните файл. Всё, ваш toolchain-файл готов.

---

3. Как использовать toolchain-файл при сборке?

Допустим, у вас есть стандартная структура проекта с главным CMakeLists.txt. Чтобы собрать проект с использованием MinGW, нужно:

1. Создать отдельную папку для сборки (это «best practice» для CMake). Например, в корне проекта:

   bash
   mkdir build-windows
   cd build-windows

2. Вызвать CMake, указав путь к вашему toolchain-mingw.cmake, который мы создали:

   bash
   cmake \
     -DCMAKE_TOOLCHAIN_FILE=../toolchain-mingw.cmake \
     -DCMAKE_BUILD_TYPE=Release \
     ../

   • .. (две точки) означает «вернуться в родительскую директорию», где лежит CMakeLists.txt.
   • Если вы положили toolchain-mingw.cmake тоже в корень проекта, то путь ../toolchain-mingw.cmake будет верным.
   • Если у вас другая структура, просто поправьте путь.

3. Собрать проект:

   bash
   cmake --build . --config Release

   или

   bash
   make -j4

   (в зависимости от того, какой генератор CMake выбрал).

4. Результат: в папке build-windows (или в подпапке bin, Release и т.п.) вы найдёте .exe файл.

---

4. Что ещё нужно знать, если у вас Qt?

Если ваш проект использует Qt, то:

1. Вам нужны библиотеки Qt под Windows (а не под macOS).

   • Самое простое: собирать проект на настоящей Windows-машине (или в виртуалке), где установлен Qt (MinGW kit).
   • Кросс-компиляция Qt на macOS под Windows — задача посложнее (надо собирать Qt самостоятельно или искать заранее собранные кросс-библиотеки).

2. Если всё же хотите кросс-компилировать прямо на Mac (редкий сценарий):

   • Придётся установить (или собрать) Qt для MinGW-w64 (Windows).
   • Указать нужные пути к include/lib-файлам Qt в toolchain-файле или в CMakeLists.txt.
   • Убедиться, что при сборке ссылки идут на нужные .lib/.dll/.a файлы.

3. При запуске .exe в Windows потребуется «доукомплектовать» его DLL от Qt (если вы не делали статическую сборку). Для этого в среде Windows обычно используют windeployqt.exe.

---

5. Итог

1. Создаёте текстовый файл toolchain-mingw.cmake в удобном для вас месте (часто – в корне проекта).
2. Наполняете его содержимым, где указываете CMAKE_SYSTEM_NAME, CMAKE_C_COMPILER, CMAKE_CXX_COMPILER и нужные флаги.
3. Вызываете cmake с флагом -DCMAKE_TOOLCHAIN_FILE=... и собираете проект.
4. В результате получаете .exe для Windows.

Если не требуется именно кросс-компиляция на Mac, то проще (и в случае Qt чаще) собирать уже под Windows (реальная система, виртуалка или Boot Camp), потому что там есть готовый установщик Qt + MinGW, и всё делается «из коробки». Но если вы хотите именно на macOS собрать под Windows — всё сводится к правильной настройке toolchain-файла и, в случае Qt, ещё и кросс-библиотек Qt.

Если утилита which x86_64-w64-mingw32-g++ показывает путь

/opt/local/bin/x86_64-w64-mingw32-g++

значит ваш кросс-компилятор лежит именно там. Соответственно, в toolchain-файле (toolchain-mingw.cmake) нужно указывать эти пути явно. Пример минимального содержимого:

cmake
# toolchain-mingw.cmake

# Указываем, что собираем под Windows
set(CMAKE_SYSTEM_NAME Windows)
set(CMAKE_SYSTEM_PROCESSOR x86_64)

# Пути к компиляторам (C и C++)
set(CMAKE_C_COMPILER /opt/local/bin/x86_64-w64-mingw32-gcc)
set(CMAKE_CXX_COMPILER /opt/local/bin/x86_64-w64-mingw32-g++)

# Рекомендуется статически линковать runtime-библиотеки 
# (чтобы не таскать libstdc++ и libgcc отдельно)
set(CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}   -static-libgcc")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -static-libstdc++ -static-libgcc")

Важно:

• Если у вас есть отдельный путь к x86_64-w64-mingw32-gcc (например, /opt/local/bin/x86_64-w64-mingw32-gcc), пропишите его точно так же.
• Если в дальнейшем CMake не найдёт нужные заголовки/библиотеки, может потребоваться дополнительно указать пути к include и lib через переменные вида CMAKE_C_FLAGS / CMAKE_CXX_FLAGS или иные настройки (зависит от конкретной конфигурации MinGW и Qt, если вы используете Qt).

После создания такого toolchain-mingw.cmake (допустим, в корне вашего проекта), вы сможете вызывать CMake так:

bash
mkdir build-windows
cd build-windows

cmake \
  -DCMAKE_TOOLCHAIN_FILE=../toolchain-mingw.cmake \
  -DCMAKE_BUILD_TYPE=Release \
  ../

cmake --build . --config Release

В результате в папке сборки появится готовый .exe под Windows.

Ниже — два варианта, как использовать toolchain-файл после его создания, чтобы собрать .exe для Windows из вашего Qt/C++ проекта под macOS. Выберите тот способ, который удобнее.

---

Вариант 1. Сборка через терминал (рекомендуется для начала)

1. Закройте Qt Creator (если открыт).
   Часто проще собрать проект в терминале, чтобы убедиться, что кросс-компиляция в принципе работает.

2. Создайте папку для сборки (например, build-windows), чтобы не «мусорить» в исходниках:

   bash
   mkdir build-windows
   cd build-windows

3. Вызовите CMake, указывая:

   • Где лежит ваш toolchain-mingw.cmake.
   • Где лежит главный CMakeLists.txt вашего проекта.
   • Какой тип сборки (Release/Debug).

   Пример (пути нужно скорректировать под ваш проект):

   bash
   cmake \
     -DCMAKE_TOOLCHAIN_FILE=/путь/к/вашему/toolchain-mingw.cmake \
     -DCMAKE_BUILD_TYPE=Release \
     /путь/к/папке/с/исходниками

4. Скомпилируйте:

   bash
   cmake --build . --config Release

   или, если CMake выбрал генератор Makefiles:

   bash
   make -j4

5. Итоговый .exe появится в папке build-windows (или в подпапке Release, в зависимости от конфигурации).

   • Теперь .exe можно скопировать в Windows и запустить.

Таким образом вы проверите, что сам процесс кросс-компиляции отлажен и работает.

---

Вариант 2. Настроить в Qt Creator «Kit» для кросс-компиляции

Если хотите прямо в Qt Creator собирать .exe:

1. Откройте Preferences (в меню Qt Creator на macOS это Qt Creator > Preferences…), затем вкладку Kits.
2. Нажмите «Add» (добавить новый кит).
3. Задайте имя, например, «MinGW Windows (Cross)».
4. В разделе «Toolchain» укажите путь к вашему MinGW-компилятору (то есть /opt/local/bin/x86_64-w64-mingw32-gcc и т. п.).
5. В разделе «CMake Toolchain File» (если Qt Creator поддерживает это поле) либо вручную пропишите -DCMAKE_TOOLCHAIN_FILE=/путь/к/toolchain-mingw.cmake в дополнительных аргументах CMake.
6. Укажите, что Debugger можно оставить пустым (или указать что-то совместимое).
7. Сохраните «Kit».

Далее:

• Откройте ваш проект в Qt Creator.
• Зайдите в Projects (слева), выберите созданный Kit («MinGW Windows (Cross)»).
• Нажмите «Configure Project», дождитесь, пока CMake сконфигурируется.
• Нажмите «Build» (или «Собрать»).

Qt Creator сделает то же самое, что и вариант №1 (вызовет CMake с указанным toolchain-файлом), только в графическом режиме.

Обратите внимание: если ваш проект использует Qt-библиотеки, то, чтобы скомпилировать под Windows, нужны Qt-библиотеки под Windows. На macOS обычно вы установили Qt под macOS — это не те же самые файлы, что нужны для Windows. В большинстве случаев кросс-компиляция Qt на macOS — довольно сложная история, поэтому зачастую проще собрать проект внутри реальной Windows (или виртуалки) с установленным Qt для MinGW.

---

Что сделать «прямо сейчас»?

1. Самый быстрый способ проверить, что всё работает:

   • Закройте Qt Creator.
   • Перейдите в терминал в папку проекта.
   • Создайте build-windows, запустите cmake -DCMAKE_TOOLCHAIN_FILE=..., далее make.
   • Убедитесь, что получился .exe.

2. Если нужно продолжать из Qt Creator, создайте новый «Kit», укажите в нём toolchain-файл, выберите этот Kit для сборки — и стройте из интерфейса Qt Creator.

Вот и всё: после этого ваш .exe будет в папке сборки; его уже можно перенести на Windows и запускать там (не забыв про необходимые DLL, если нужны внешние библиотеки).

Судя по сообщению zsh: command not found: cmake, у вас не установлен (или не прописан в PATH) cmake. А также видно, что вторая строка воспринимается как отдельная команда из-за неправильной записи переносов. Ниже по шагам, как это исправить:

---

1. Установите (или проверьте наличие) CMake

Вариант через Homebrew

Если у вас установлен Homebrew, можно выполнить:

bash
brew install cmake

После установки введите:

bash
which cmake

Если в ответ получаете что-то вроде /usr/local/bin/cmake или /opt/homebrew/bin/cmake (в зависимости от процессора и настройки Homebrew), значит CMake доступен.

Вариант через MacPorts

Если вы используете MacPorts (похоже, вы устанавливали MinGW из MacPorts, так как компилятор лежит в /opt/local/bin), то можно установить CMake так:

bash
sudo port install cmake

Затем проверьте, что cmake доступен командой:

bash
which cmake

---

2. Правильно используйте многострочную команду

При использовании слэшей (\) для переноса аргументов в zsh/bash важно, чтобы после слэша не было других символов и не было пропуска (пробела) до слэша. Например:

bash
cmake \
  -DCMAKE_TOOLCHAIN_FILE=/Users/filippkudravcev/Desktop/cma/toolchain-mingw.cmake \
  -DCMAKE_BUILD_TYPE=Release \
  /Users/filippkudravcev/vlad_popov

Обратите внимание, что везде, где мы хотим перенести строку, строка заканчивается \ сразу, без пробелов. Такая команда отработает как одна строка.

Если удобнее, можете просто записать одной строкой:

bash
cmake -DCMAKE_TOOLCHAIN_FILE=/Users/filippkudravcev/Desktop/cma/toolchain-mingw.cmake -DCMAKE_BUILD_TYPE=Release /Users/filippkudravcev/vlad_popov

---

3. Проверьте, что находитесь в правильной папке сборки

Как правило, в CMake-проектах рекомендуют создавать отдельную папку под сборку. Например, сделайте так:

bash
cd /Users/filippkudravcev/vlad_popov       # где лежит ваш CMakeLists.txt
mkdir build-windows
cd build-windows

А затем уже вызывайте cmake (и указывайте путь к исходникам «на уровень выше»):

bash
cmake \
  -DCMAKE_TOOLCHAIN_FILE=/Users/filippkudravcev/Desktop/cma/toolchain-mingw.cmake \
  -DCMAKE_BUILD_TYPE=Release \
  ..

Обратите внимание на .. (две точки) — это путь к родительской папке, где, собственно, лежит CMakeLists.txt.

---

4. Скомпилируйте

После успешной конфигурации (если CMake напишет, что всё ок), запустите сборку:

bash
cmake --build . --config Release

или, если CMake выбрал Makefiles:

bash
make -j4

---

Итог

1. Убедитесь, что cmake установлен и находится в PATH (проверка командой which cmake).
2. Исправьте синтаксис многострочной команды, чтобы каждая строка заканчивалась \ без пробела после него.
3. Собирайте в отдельной папке:
   • mkdir build-windows && cd build-windows
   • cmake -DCMAKE_TOOLCHAIN_FILE=... -DCMAKE_BUILD_TYPE=Release ..
   • cmake --build .

Таким образом вы избежите ошибки zsh: command not found: cmake и ошибок многострочного ввода.

Эта ошибка означает, что при сборке проект не может найти Qt, а именно — конфигурационные файлы Qt6Config.cmake, Qt5Config.cmake и т.п. Причина в том, что вы пытаетесь кросс-компилировать на macOS под Windows, а у вас нет установленных Qt-библиотек именно для Windows (MinGW-версия).

Ниже разберём, почему так происходит и какие есть варианты решения.

---

1. Почему CMake не находит Qt?

Когда вы пишете в CMakeLists.txt что-то вроде:

cmake
find_package(Qt6 COMPONENTS Core Widgets REQUIRED)

или

cmake
find_package(Qt5 COMPONENTS Core Widgets REQUIRED)

CMake ищет файлы конфигурации вида:

• Qt6Config.cmake (для Qt6)
• Qt5Config.cmake (для Qt5)

На macOS обычно стоит Qt собранный под macOS (к примеру, /Users/username/Qt/5.15.2/clang_64/), но при кросс-компиляции вы пытаетесь «превратить» ваш код в .exe для Windows. Поэтому нужны именно библиотеки Qt для MinGW (Windows). macOS-вариант Qt здесь не подойдёт.

---

2. Варианты решения

Вариант A: Собирать проект под Windows (проще всего)

1. Поставить/запустить Windows (реально или виртуалку).
2. Установить Qt для MinGW (через Qt Online Installer, выбрав опцию MinGW).
3. Установить CMake и MinGW.
4. Собрать проект в среде, где Qt под Windows «из коробки» доступен.

Это самый надёжный и быстрый способ получить рабочий .exe, так как не придётся самому собирать Qt под Windows на macOS.

Вариант B: Кросс-компилировать Qt под Windows на macOS (сложнее)

1. Скачать исходники Qt нужной версии (Qt5 или Qt6).
2. Скомпилировать Qt с MinGW-w64 кросс-компилятором (тем же, что вы используете). Это довольно непростой процесс: придётся правильно настроить системные флаги, пути и т. д.
3. Получить в итоге «кросс-собранные» библиотеки Qt (файлы .a, .lib, .dll и т. п. для Windows, но сгенерированные на вашем Mac).
4. Указать CMake, где искать эти библиотеки. Например, прописать:

   bash
   cmake \
     -DCMAKE_TOOLCHAIN_FILE=.../toolchain-mingw.cmake \
     -DCMAKE_BUILD_TYPE=Release \
     -DCMAKE_PREFIX_PATH=/Users/filippkudravcev/qt-for-windows-mingw \
     /Users/filippkudravcev/vlad_popov

   И тогда CMake найдёт соответствующие Qt5Config.cmake или Qt6Config.cmake именно под MinGW/Windows.

Вариант C: Перейти на другой фреймворк / не использовать Qt

Если по какой-то причине вы просто экспериментируете, и Qt под Windows не так принципиален, можно использовать другой toolkit или вообще чистый C++ (но это, скорее всего, не ваш случай).

---

3. Что значит Add the installation prefix of "QT" to CMAKE_PREFIX_PATH?

В сообщении CMake написано, что нужно добавить «установочный префикс» Qt в переменную CMAKE_PREFIX_PATH. Иными словами, CMake должен знать, где лежат файлы Qt5Config.cmake или Qt6Config.cmake. Для сборки под Windows эти файлы должны быть именно из версии Qt для Windows.

Пример (на Windows или при кросс-компиляции, если Qt уже собран под MinGW):

bash
cmake \
  -DCMAKE_PREFIX_PATH="C:/Qt/6.5.0/mingw_64" \
  ...

(или в вашем случае — путь к кросс-собранному Qt на Mac).

---

4. Итого

1. Ошибка указывает на то, что нет Qt-библиотек для Windows.
2. Самый простой путь: собрать проект внутри среды Windows, где Qt для MinGW уже установлен.
3. Если вы упорно хотите собрать всё под macOS:
   • Нужно скомпилировать Qt для MinGW (Windows),
   • Указать CMAKE_PREFIX_PATH на «кросс-собранное» Qt,
   • Убедиться, что ссылки идут именно на библиотеки для Windows, а не macOS.

Иначе CMake просто не найдёт нужные файлы конфигурации Qt5Config.cmake / Qt6Config.cmake, потому что macOS-версия Qt и Windows-версия Qt — это разные наборы файлов, которые не взаимозаменяемы.