自定义 C++ 编译器的调用与管理

最新推荐文章于 2024-12-26 12:40:24 发布
最新推荐文章于 2024-12-26 12:40:24 发布
阅读量566 收藏 7
点赞数 20
分类专栏： 桌面应用开发 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_58648890/article/details/144637069
版权

在 C++ 项目中，常常需要自动化地管理编译流程，例如使用 MinGW 或 Visual Studio 编译器进行代码的编译和链接。为了方便管理不同编译器和简化编译流程，我们开发了一个 CompilerManager 类，用于抽象编译器的查找、命令生成以及执行。

本文将详细介绍这个编译管理器的设计、功能实现以及如何在实际项目中使用。

项目背景

在实际开发中，跨平台编译器管理是一个复杂的问题，不同的操作系统、不同的编译工具链都会对项目开发带来一定的复杂性。尤其是当一个项目需要支持 MinGW 和 Visual Studio 两种编译器时，用户不仅需要手动配置环境，还需要通过命令行正确调用编译命令。

为了解决上述问题，本文设计了一个通用的编译管理器类 CompilerManager，支持以下功能：

  • 自动检测编译器：根据环境变量或预定义路径，自动查找 MinGW 和 Visual Studio 的编译器路径。
  • 支持两种编译模式：
    • MinGW：直接调用 g++，完成源文件到可执行文件的编译。
    • Visual Studio：分离编译和链接阶段，分别生成 .obj 文件和最终的可执行文件。
  • 封装编译命令：自动根据编译器生成正确的编译和链接命令。
  • 动态设置环境变量：支持通过 _putenv 动态设置 PATH、INCLUDE 和 LIB 环境变量，确保 Visual Studio 的命令行工具能够正确工作。
  • 执行命令捕获输出：封装命令执行，支持捕获输出和错误信息。

编译管理器的核心功能

编译管理器类设计

CompilerManager 类封装了编译器的查找、命令生成和执行逻辑。以下是它的核心成员变量和方法：

#pragma once

#include <string>
#include <vector>

// 编译器管理类
class CompilerManager {
public:
    // 枚举类型：支持 MinGW 和 Visual Studio
    enum CompilerType {
        MinGW,
        VisualStudio
    };

    // 构造函数
    CompilerManager();

    // 从注册表中读取路径
    std::string GetDebuggerPathFromRegistry(const std::string& regKey, const std::string& regValue);

    // 设置编译器类型
    void SetCompilerType(CompilerType type);

    // 自动查找编译器路径
    bool FindCompiler(std::string& outputMessage);

    // 获取 C 编译器路径
    std::string GetCCompilerPath() const;

    // 获取 C++ 编译器路径
    std::string GetCppCompilerPath() const;

    // 获取编译器版本
    std::string GetCompilerVersion() const;

	// 编译单个文件
    bool CompileSingleFile(const std::string& sourceFile, const std::string& outputFile, std::string& outputMessage);

	// 编译多个文件
    bool CompileMultipleFiles(const std::vector<std::string>& sourceFiles, const std::string& outputFile, std::string& outputMessage);

private:
    // 检查文件是否存在
    bool FileExists(const std::string& path);

	// 查找 MinGW 编译器
    bool FindMinGW(std::string& outputMessage);

    // 查找 Microsoft 调试器路径
    bool FindMicrosoftDebugger(std::string& debuggerPath);

    // 查找 LLDB 调试器路径
    bool FindLLDBDebugger(std::string& debuggerPath, std::string& errorMessage);

	// 查找 Visual Studio 调试器路径
    bool FindVisualStudioLinker(const std::string& vsPath, std::string& linkerPath);

	// 查找 Visual Studio 的安装路径记录
    std::string FindVswhereFromRegistry();

    // 调用 vcvarsall.bat 初始化 Visual Studio 环境
    bool InitializeEnvironment(std::string& outputMessage);

	// 查找 Visual Studio 编译器
    bool FindVisualStudio(std::string& outputMessage);

    std::string GetEnvironmentVariableSafe(const std::string& variableName);

	// 在 PATH 环境变量中查找可执行文件
    std::string FindInPath(const std::string& executable);

	// 执行命令行命令
    std::string ExecuteCommand(const std::string& command);

    // 构建编译命令
    std::string BuildCompileCommand(const std::vector<std::string>& sourceFiles, const std::string& outputFile, std::string& outputMessage);

    // 构建链接命令
    std::string BuildLinkCommand(const std::vector<std::string>& objectFiles, const std::string& outputFile, std::string& outputMessage);

	// 执行编译命令
    bool ExecuteCompileCommand(const std::string& command, std::string& outputMessage);

private:
    CompilerType m_compilerType;        // 当前选择的编译器类型
    std::string m_workspacePath;        // 工作集路径
    std::string m_cCompilerPath;        // C 编译器路径
    std::string m_cppCompilerPath;      // C++ 编译器路径
	std::string m_linkerPath;           // 链接器路径
    std::string m_buildToolPath;        // 构建工具路径
    std::string m_debuggerPath;         // 调试器路径
    std::string m_compilerVersion;      // 编译器版本信息
};

编译器路径查找

  1. MinGW 查找：通过 PATH 环境变量搜索 gcc.exe 和 g++.exe。
  2. Visual Studio 查找：通过调用 vswhere.exe 或解析注册表，获取最新版本 Visual Studio 的安装路径，并找到 cl.exe 和 link.exe。

示例代码如下：

bool CompilerManager::FindMinGW(std::string& outputMessage) {
	// 查找工具路径
	std::string gccPath = FindInPath("gcc.exe");
	std::string gppPath = FindInPath("g++.exe");
	std::string gdbPath = FindInPath("gdb.exe");
	std::string ldPath = FindInPath("ld.exe");

	// 如果任何一个工具未找到，则返回错误
	if (gccPath.empty() || gppPath.empty() || gdbPath.empty()) {
		outputMessage = "Error: MinGW tools not found in PATH.\n";
		if (gccPath.empty()) outputMessage += "C Compiler (gcc.exe) not found.\n";
		if (gppPath.empty()) outputMessage += "C++ Compiler (g++.exe) not found.\n";
		if (gdbPath.empty()) outputMessage += "Debugger (gdb.exe) not found.\n";
		if (ldPath.empty()) outputMessage += "Linker (ld.exe) not found.\n";
		return false;
	}

	// 设置工具路径
	m_cCompilerPath = gccPath;
	m_cppCompilerPath = gppPath;
	m_debuggerPath = gdbPath;
	m_linkerPath = ldPath;

	// 验证工具是否在同一目录中
	std::size_t gccPos = gccPath.find_last_of("\\/");
	std::size_t gppPos = gppPath.find_last_of("\\/");
	std::size_t gdbPos = gdbPath.find_last_of("\\/");
	std::size_t ldPos = ldPath.find_last_of("\\/");

	if (gccPath.substr(0, gccPos) != gppPath.substr(0, gppPos) ||
		gccPath.substr(0, gccPos) != gdbPath.substr(0, gdbPos) ||
		gdbPath.substr(0, gdbPos) != ldPath.substr(0, ldPos)) {
		m_workspacePath = "";
		outputMessage = "Error: MinGW tools are not located in the same directory.\n";
		return false;
	}
	else {
		if (gccPos != std::string::npos) {
			m_workspacePath = gccPath.substr(0, gccPos);
		}
	}

	// 获取编译器版本信息
	m_compilerVersion = ExecuteCommand(gccPath + " --version");
	if (m_compilerVersion.empty()) {
		outputMessage = "Error: Failed to retrieve MinGW compiler version.";
		return false;
	}

	// 输出成功信息
	outputMessage = "=========================================\n";
	outputMessage += " MinGW Tools Found\n";
	outputMessage += "=========================================\n";
	outputMessage += "C Compiler   : " + m_cCompilerPath + "\n";
	outputMessage += "C++ Compiler : " + m_cppCompilerPath + "\n";
	outputMessage += "Debugger     : " + m_debuggerPath + "\n";
	outputMessage += "Linker       : " + m_linkerPath + "\n";
	outputMessage += "Workspace    : " + m_workspacePath + "\n";
	outputMessage += "\nVersion:\n" + m_compilerVersion;

	return true;
}

bool CompilerManager::FindVisualStudio(std::string& outputMessage) {
	std::string vswherePath = "C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer\\vswhere.exe";
	if (!FileExists(vswherePath)) {
		vswherePath = FindVswhereFromRegistry();
		if (!FileExists(vswherePath)) {
			std::string vswherePath = FindInPath("vswhere.exe");
			if (vswherePath.empty()) {
				outputMessage = "Error: vswhere.exe not found. Please ensure it is installed and accessible.";
				return false;
			}
		}
	}

	// 调用 vswhere.exe 获取 Visual Studio 的安装路径
	std::string vsPath = ExecuteCommand("\"" + vswherePath + "\" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath");
	if (vsPath.empty()) {
		outputMessage = "Error: Failed to locate Visual Studio installation.";
		return false;
	}
	
	// 去掉返回路径的末尾换行符
	if (!vsPath.empty() && vsPath.back() == '\n') {
		vsPath.pop_back();
	}

	// 拼接路径到 cl.exe
	std::string clPath = vsPath + "\\VC\\Tools\\MSVC";
	std::string clExePath;

	// 遍历目录，寻找 cl.exe
	std::istringstream stream(ExecuteCommand("dir \"" + clPath + "\" /b /s"));
	std::string line;
	while (std::getline(stream, line)) {
		if (line.find("cl.exe") != std::string::npos) {
			clExePath = line;
			break;
		}
	}

	if (clExePath.empty()) {
		outputMessage = "Error: Failed to find cl.exe in Visual Studio installation.";
		return false;
	}

	// 获取调试器路径（优先查找 Microsoft 调试器）
	std::string debuggerPath;
	if (!FindMicrosoftDebugger(debuggerPath)) {
		// 如果未找到 Microsoft 调试器，尝试查找 LLDB 调试器
		if (!FindLLDBDebugger(debuggerPath, outputMessage)) {
			outputMessage = "Error: Failed to find a compatible debugger (cdb.exe or lldb.exe).";
			return false;
		}
	}

	// 获取链接器路径
	std::string linkerPath;
	if (!FindVisualStudioLinker(vsPath, linkerPath)) {
		outputMessage = "Error: Failed to find link.exe in Visual Studio installation.";
		return false;
	}

	m_workspacePath = vsPath;
	m_cCompilerPath = clExePath;
	m_cppCompilerPath = clExePath;
	m_linkerPath = linkerPath;
	m_debuggerPath = debuggerPath;

	if (!InitializeEnvironment(outputMessage)) {
		return false;
	}

	m_compilerVersion = ExecuteCommand("\"" + m_cCompilerPath + "\" /?");
	if (m_compilerVersion.empty()) {
		outputMessage = "Error: Failed to retrieve Visual Studio compiler version.";
		return false;
	}

	// 输出成功信息
	outputMessage = "=========================================\n";
	outputMessage = " Visual Studio compilers found:\n";
	outputMessage += "=========================================\n";
	outputMessage += "C Compiler   : " + m_cCompilerPath + "\n";
	outputMessage += "C++ Compiler : " + m_cppCompilerPath + "\n";
	outputMessage += "Debugger     : " + m_debuggerPath + "\n";
	outputMessage += "Linker       : " + m_linkerPath + "\n";
	outputMessage += "Workspace    : " + m_workspacePath + "\n";
	outputMessage += "\nVersion:\n" + m_compilerVersion;

	return true;
}

构建编译命令

BuildCompileCommand 方法根据不同编译器生成正确的编译命令：

  • MinGW：
    g++ source.cpp -o output.exe
  • Visual Studio：
    cl.exe /EHsc /I<include_path> source.cpp /Fo<output.obj> /Zi

使用方法

下面是如何在项目中使用 CompilerManager 类：

CompilerManager manager;

// 设置编译器类型为 MinGW 或 Visual Studio
manager.SetCompilerType(CompilerManager::MinGW);
// manager.SetCompilerType(CompilerManager::VisualStudio);

// 查找编译器
std::string outputMessage;
if (manager.FindCompiler(outputMessage)) {
    std::cout << "Compiler found successfully!" << std::endl;
    std::cout << outputMessage << std::endl;
} else {
    std::cerr << "Failed to find compiler." << std::endl;
    std::cerr << outputMessage << std::endl;
}

// 编译单个文件
std::string sourceFile = "D:\WorkCode\Demo\MyTest\main.cpp";
std::string outputFile = "D:\WorkCode\Demo\MyTest\main.exe";

if (manager.CompileSingleFile(sourceFile, outputFile, outputMessage)) {
    std::cout << "Compilation successful!" << std::endl;
} else {
    std::cerr << "Compilation failed!" << std::endl;
    std::cerr << outputMessage << std::endl;
}

存在的问题与改进计划

目前 CompilerManager 的核心功能已实现，但在 Visual Studio 的使用中仍存在问题：

  1. 编译错误：在 Visual Studio 中，编译时输出错误 STL1001: Unexpected compiler version。
    • 原因：可能是环境变量未正确设置，或者调用了错误版本的 cl.exe。
    • 改进计划：进一步优化 _putenv 的动态环境配置，确保正确的编译器版本被调用。
  2. 分离编译和链接：对于多文件项目，尚未完全实现分离编译（生成 .obj 文件）与链接（生成可执行文件）的功能。

总结

通过 CompilerManager 类，我们能够简化项目的编译管理流程，并支持自动化调用 MinGW 和 Visual Studio 的编译器。虽然目前 Visual Studio 的支持仍需进一步完善，但这个管理器已经为多编译器支持提供了一个良好的基础。

在这篇文章中，我们介绍了如何使用 CompilerManager 类管理代码编译。这个工具类通过调用现有编译器（如 MinGW 和 Visual Studio）来完成源代码的编译任务，而不是重新实现一个编译器。通过对编译器路径的检测和环境变量的初始化，CompilerManager 提供了一种方便的方式来管理不同编译器的使用。

完整代码：CompilerManager.cpp

#include "pch.h"
#include "CompilerManager.h"
#include <sstream>
#include <cstdlib>
#include <iostream>
#include <fstream>
#include <cstdio>
#include <algorithm>

// 构造函数
CompilerManager::CompilerManager() : m_compilerType(MinGW) {}

// 从注册表中读取路径
std::string CompilerManager::GetDebuggerPathFromRegistry(const std::string& regKey, const std::string& regValue) {
	HKEY hKey;
	char value[512];
	DWORD valueLength = sizeof(value);

	// 打开注册表键
	if (RegOpenKeyExA(HKEY_LOCAL_MACHINE, regKey.c_str(), 0, KEY_READ, &hKey) != ERROR_SUCCESS) {
		return "";
	}

	// 查询注册表值
	if (RegQueryValueExA(hKey, regValue.c_str(), nullptr, nullptr, (LPBYTE)value, &valueLength) == ERROR_SUCCESS) {
		RegCloseKey(hKey);
		return std::string(value);
	}

	RegCloseKey(hKey);
	return "";
}

// 设置编译器类型
void CompilerManager::SetCompilerType(CompilerType type) {
	m_compilerType = type;
}

// 自动查找编译器路径
bool CompilerManager::FindCompiler(std::string& outputMessage) {
	if (m_compilerType == MinGW) {
		return FindMinGW(outputMessage);
	}
	if (m_compilerType == VisualStudio) {
		return FindVisualStudio(outputMessage);
	}
	outputMessage = "Error: Unknown compiler type.";
	return false;
}

// 获取 C 编译器路径
std::string CompilerManager::GetCCompilerPath() const {
	return m_cCompilerPath;
}

// 获取 C++ 编译器路径
std::string CompilerManager::GetCppCompilerPath() const {
	return m_cppCompilerPath;
}

// 获取编译器版本
std::string CompilerManager::GetCompilerVersion() const {
	return m_compilerVersion;
}

// 编译单个文件
bool CompilerManager::CompileSingleFile(const std::string& sourceFile, const std::string& outputFile, std::string& outputMessage) {
	// 检查源文件是否存在
	if (!FileExists(sourceFile)) {
		outputMessage = "Error: Source file not found: " + sourceFile;
		return false;
	}

	// 构建编译命令
	std::vector<std::string> sourceFiles = { sourceFile };
	std::string compileCommand = BuildCompileCommand(sourceFiles, outputFile, outputMessage);
	if (compileCommand.empty())	{
		outputMessage = "Error: Failed to build compile command.";
		return false;
	}

	std::cout << "CompileCommand Output: " << compileCommand << std::endl;

	// 执行编译命令
	return ExecuteCompileCommand(compileCommand, outputMessage);
}

// 编译多个文件
bool CompilerManager::CompileMultipleFiles(const std::vector<std::string>& sourceFiles, const std::string& outputFile, std::string& outputMessage) {
	// 检查每个源文件是否存在
	for (const auto& file : sourceFiles) {
		if (!FileExists(file)) {
			outputMessage = "Error: Source file not found: " + file;
			return false;
		}
	}

	// 构建编译命令
	std::string compileCommand = BuildCompileCommand(sourceFiles, outputFile, outputMessage);
	if (compileCommand.empty()) {
		outputMessage = "Error: Failed to build compile command.";
		return false;
	}

	// 执行编译命令
	return ExecuteCompileCommand(compileCommand, outputMessage);
}

// 检查文件是否存在
bool CompilerManager::FileExists(const std::string& path) {
	std::ifstream file(path);
	return file.good();
}

// 查找 MinGW 编译器
bool CompilerManager::FindMinGW(std::string& outputMessage) {
	// 查找工具路径
	std::string gccPath = FindInPath("gcc.exe");
	std::string gppPath = FindInPath("g++.exe");
	std::string gdbPath = FindInPath("gdb.exe");
	std::string ldPath = FindInPath("ld.exe");

	// 如果任何一个工具未找到，则返回错误
	if (gccPath.empty() || gppPath.empty() || gdbPath.empty()) {
		outputMessage = "Error: MinGW tools not found in PATH.\n";
		if (gccPath.empty()) outputMessage += "C Compiler (gcc.exe) not found.\n";
		if (gppPath.empty()) outputMessage += "C++ Compiler (g++.exe) not found.\n";
		if (gdbPath.empty()) outputMessage += "Debugger (gdb.exe) not found.\n";
		if (ldPath.empty()) outputMessage += "Linker (ld.exe) not found.\n";
		return false;
	}

	// 设置工具路径
	m_cCompilerPath = gccPath;
	m_cppCompilerPath = gppPath;
	m_debuggerPath = gdbPath;
	m_linkerPath = ldPath;

	// 验证工具是否在同一目录中
	std::size_t gccPos = gccPath.find_last_of("\\/");
	std::size_t gppPos = gppPath.find_last_of("\\/");
	std::size_t gdbPos = gdbPath.find_last_of("\\/");
	std::size_t ldPos = ldPath.find_last_of("\\/");

	if (gccPath.substr(0, gccPos) != gppPath.substr(0, gppPos) ||
		gccPath.substr(0, gccPos) != gdbPath.substr(0, gdbPos) ||
		gdbPath.substr(0, gdbPos) != ldPath.substr(0, ldPos)) {
		m_workspacePath = "";
		outputMessage = "Error: MinGW tools are not located in the same directory.\n";
		return false;
	}
	else {
		if (gccPos != std::string::npos) {
			m_workspacePath = gccPath.substr(0, gccPos);
		}
	}

	// 获取编译器版本信息
	m_compilerVersion = ExecuteCommand(gccPath + " --version");
	if (m_compilerVersion.empty()) {
		outputMessage = "Error: Failed to retrieve MinGW compiler version.";
		return false;
	}

	// 输出成功信息
	outputMessage = "=========================================\n";
	outputMessage += " MinGW Tools Found\n";
	outputMessage += "=========================================\n";
	outputMessage += "C Compiler   : " + m_cCompilerPath + "\n";
	outputMessage += "C++ Compiler : " + m_cppCompilerPath + "\n";
	outputMessage += "Debugger     : " + m_debuggerPath + "\n";
	outputMessage += "Linker       : " + m_linkerPath + "\n";
	outputMessage += "Workspace    : " + m_workspacePath + "\n";
	outputMessage += "\nVersion:\n" + m_compilerVersion;

	return true;
}

// 查找 Microsoft 调试器路径
bool CompilerManager::FindMicrosoftDebugger(std::string& debuggerPath) {
	// 从注册表获取 Windows SDK 根目录
	std::vector<std::pair<std::string, std::string>> registryKeys = {
		{"SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots", "KitsRoot10"}, // Windows 10 SDK
		{"SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots", "KitsRoot81"}, // Windows 8.1 SDK
		{"SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots", "KitsRoot"}    // Windows 8 SDK
	};

	for (const auto& item : registryKeys) {
		std::string sdkRoot = GetDebuggerPathFromRegistry(item.first, item.second);
		if (!sdkRoot.empty()) {
			// 构造调试器路径
			std::vector<std::string> potentialPaths = {
				sdkRoot + "Debuggers\\x64\\cdb.exe",
				sdkRoot + "Debuggers\\x86\\cdb.exe"
			};

			// 检查是否存在
			for (const auto& path : potentialPaths) {
				if (FileExists(path)) {
					debuggerPath = path;
					return true;
				}
			}
		}
	}

	debuggerPath = "";
	return false; // 未找到调试器
}

// 查找 LLDB 调试器路径
bool CompilerManager::FindLLDBDebugger(std::string& debuggerPath, std::string& errorMessage) {
	// 从环境变量获取 LLVM 安装路径
	std::string llvmPath = GetEnvironmentVariableSafe("LLVM_DIR");
	if (!llvmPath.empty()) {
		std::string lldbPath = llvmPath + "\\bin\\lldb.exe";
		if (FileExists(lldbPath)) {
			debuggerPath = lldbPath;
			return true;
		}
		else {
			errorMessage = "Error: LLDB not found in LLVM_DIR (" + llvmPath + ").";
		}
	}
	else {
		errorMessage = "Error: LLVM_DIR environment variable is not set.";
	}

	// 默认路径检查
	std::vector<std::string> defaultPaths = {
		"C:\\Program Files\\LLVM\\bin\\lldb.exe",
		"C:\\Program Files (x86)\\LLVM\\bin\\lldb.exe"
	};

	for (const auto& path : defaultPaths) {
		if (FileExists(path)) {
			debuggerPath = path;
			return true;
		}
	}

	errorMessage += " LLDB not found in default installation paths.";
	debuggerPath = "";
	return false;
}

bool CompilerManager::FindVisualStudioLinker(const std::string& vsPath, std::string& linkerPath) {
	std::string clPath = vsPath + "\\VC\\Tools\\MSVC";
	std::istringstream stream(ExecuteCommand("dir \"" + clPath + "\" /b /s"));
	std::string line;

	while (std::getline(stream, line)) {
		if (line.find("link.exe") != std::string::npos) {
			linkerPath = line;
			return true; // 找到链接器
		}
	}

	linkerPath = "";
	return false; // 未找到链接器
}

std::string CompilerManager::FindVswhereFromRegistry() {
	HKEY hKey;
	char value[512];
	DWORD valueLength = sizeof(value);

	// 打开注册表路径
	if (RegOpenKeyExA(HKEY_LOCAL_MACHINE,
		"SOFTWARE\\Microsoft\\VisualStudio\\Setup",
		0,
		KEY_READ,
		&hKey) != ERROR_SUCCESS) {
		return "";
	}

	// 读取 SharedInstallationPath
	if (RegQueryValueExA(hKey, "SharedInstallationPath", nullptr, nullptr, (LPBYTE)value, &valueLength) == ERROR_SUCCESS) {
		RegCloseKey(hKey);
		return std::string(value) + "\\vswhere.exe";
	}

	RegCloseKey(hKey);
	return "";
}

// 调用 vcvarsall.bat 初始化 Visual Studio 环境
bool CompilerManager::InitializeEnvironment(std::string& outputMessage) {
	// 定义临时文件路径
	std::string tempFilePath = "vcvars_output.txt";

	// 构造命令，将 vcvarsall.bat 执行结果和环境变量输出到文件
	std::string vcvarsCommand = "cmd /c \"\"" + m_workspacePath + "\\VC\\Auxiliary\\Build\\vcvarsall.bat\" x64 && set > " + tempFilePath + "\"";

	// 执行命令
	int commandResult = system(vcvarsCommand.c_str());
	if (commandResult != 0) {
		outputMessage = "Error: Failed to execute vcvarsall.bat.";
		return false;
	}

	// 打开临时文件
	std::ifstream inputFile(tempFilePath);
	if (!inputFile.is_open()) {
		outputMessage = "Error: Failed to open temporary output file.";
		return false;
	}

	// 逐行解析文件内容
	std::string line;
	bool includeSet = false, libSet = false, pathSet = false;

	while (std::getline(inputFile, line)) {
		size_t equalsPos = line.find('=');
		if (equalsPos != std::string::npos) {
			std::string key = line.substr(0, equalsPos);
			std::string value = line.substr(equalsPos + 1);

			// 设置环境变量到当前进程
			_putenv_s(key.c_str(), value.c_str());

			// 将 key 转换为大写
			std::string upperKey = key;
			std::transform(upperKey.begin(), upperKey.end(), upperKey.begin(), ::toupper);

			// 检查关键变量是否设置
			if (upperKey == "INCLUDE") includeSet = true;
			if (upperKey == "LIB") libSet = true;
			if (upperKey == "PATH") pathSet = true;
		}
	}

	// 关闭文件并删除临时文件
	inputFile.close();
	remove(tempFilePath.c_str());

	// 验证关键变量是否设置成功
	if (!includeSet || !libSet || !pathSet) {
		outputMessage = "Error: INCLUDE, LIB, or PATH not set.";
		return false;
	}

	outputMessage = "Environment initialized successfully.";
	return true;
}

// 查找 Visual Studio 编译器
bool CompilerManager::FindVisualStudio(std::string& outputMessage) {
	std::string vswherePath = "C:\\Program Files (x86)\\Microsoft Visual Studio\\Installer\\vswhere.exe";
	if (!FileExists(vswherePath)) {
		vswherePath = FindVswhereFromRegistry();
		if (!FileExists(vswherePath)) {
			std::string vswherePath = FindInPath("vswhere.exe");
			if (vswherePath.empty()) {
				outputMessage = "Error: vswhere.exe not found. Please ensure it is installed and accessible.";
				return false;
			}
		}
	}

	// 调用 vswhere.exe 获取 Visual Studio 的安装路径
	std::string vsPath = ExecuteCommand("\"" + vswherePath + "\" -latest -products * -requires Microsoft.VisualStudio.Component.VC.Tools.x86.x64 -property installationPath");
	if (vsPath.empty()) {
		outputMessage = "Error: Failed to locate Visual Studio installation.";
		return false;
	}
	
	// 去掉返回路径的末尾换行符
	if (!vsPath.empty() && vsPath.back() == '\n') {
		vsPath.pop_back();
	}

	// 拼接路径到 cl.exe
	std::string clPath = vsPath + "\\VC\\Tools\\MSVC";
	std::string clExePath;

	// 遍历目录，寻找 cl.exe
	std::istringstream stream(ExecuteCommand("dir \"" + clPath + "\" /b /s"));
	std::string line;
	while (std::getline(stream, line)) {
		if (line.find("cl.exe") != std::string::npos) {
			clExePath = line;
			break;
		}
	}

	if (clExePath.empty()) {
		outputMessage = "Error: Failed to find cl.exe in Visual Studio installation.";
		return false;
	}

	// 获取调试器路径（优先查找 Microsoft 调试器）
	std::string debuggerPath;
	if (!FindMicrosoftDebugger(debuggerPath)) {
		// 如果未找到 Microsoft 调试器，尝试查找 LLDB 调试器
		if (!FindLLDBDebugger(debuggerPath, outputMessage)) {
			outputMessage = "Error: Failed to find a compatible debugger (cdb.exe or lldb.exe).";
			return false;
		}
	}

	// 获取链接器路径
	std::string linkerPath;
	if (!FindVisualStudioLinker(vsPath, linkerPath)) {
		outputMessage = "Error: Failed to find link.exe in Visual Studio installation.";
		return false;
	}

	m_workspacePath = vsPath;
	m_cCompilerPath = clExePath;
	m_cppCompilerPath = clExePath;
	m_linkerPath = linkerPath;
	m_debuggerPath = debuggerPath;

	if (!InitializeEnvironment(outputMessage)) {
		return false;
	}

	m_compilerVersion = ExecuteCommand("\"" + m_cCompilerPath + "\" /?");
	if (m_compilerVersion.empty()) {
		outputMessage = "Error: Failed to retrieve Visual Studio compiler version.";
		return false;
	}

	// 输出成功信息
	outputMessage = "=========================================\n";
	outputMessage = " Visual Studio compilers found:\n";
	outputMessage += "=========================================\n";
	outputMessage += "C Compiler   : " + m_cCompilerPath + "\n";
	outputMessage += "C++ Compiler : " + m_cppCompilerPath + "\n";
	outputMessage += "Debugger     : " + m_debuggerPath + "\n";
	outputMessage += "Linker       : " + m_linkerPath + "\n";
	outputMessage += "Workspace    : " + m_workspacePath + "\n";
	outputMessage += "\nVersion:\n" + m_compilerVersion;

	return true;
}

std::string CompilerManager::GetEnvironmentVariableSafe(const std::string& variableName) {
	char* buffer = nullptr;
	size_t size = 0;

	// 使用 _dupenv_s 获取环境变量值
	if (_dupenv_s(&buffer, &size, variableName.c_str()) == 0 && buffer != nullptr) {
		std::string value(buffer); // 转换为 std::string
		free(buffer);              // 释放分配的内存
		return value;
	}

	return ""; // 如果获取失败，则返回空字符串
}

// 从 PATH 环境变量中查找可执行文件
std::string CompilerManager::FindInPath(const std::string& executable) {
	// 获取 PATH 环境变量值
	std::string path = GetEnvironmentVariableSafe("PATH");
	if (path.empty()) {
		return ""; // 如果 PATH 为空，直接返回
	}

	std::istringstream stream(path); // 按分号分割 PATH
	std::string directory;
	std::string fullPath;

	while (std::getline(stream, directory, ';')) {
		fullPath = directory + "\\" + executable; // 拼接目录和文件名
		if (FileExists(fullPath)) { // 如果找到可执行文件
			return fullPath;
		}
	}

	return ""; // 如果未找到，返回空字符串
}

// 执行命令并返回输出
std::string CompilerManager::ExecuteCommand(const std::string& command) {
	char buffer[128];
	std::string result;
	FILE* pipe = _popen((command + " 2>&1").c_str(), "r"); // 将错误输出重定向到标准输出
	if (!pipe) {
		return "";
	}
	while (fgets(buffer, sizeof(buffer), pipe) != nullptr) {
		result += buffer;
	}
	_pclose(pipe);
	return result;
}

// 构建编译命令
std::string CompilerManager::BuildCompileCommand(const std::vector<std::string>& sourceFiles, const std::string& outputFile, std::string& outputMessage) {
	std::string command;

	// 检查输入是否有效
	if (sourceFiles.empty()) {
		outputMessage = "Error: No source files provided for compilation.";
		return "";
	}
	if (outputFile.empty()) {
		outputMessage = "Error: No output file specified.";
		return "";
	}

	if (m_compilerType == MinGW) {
		// MinGW 编译命令
		command = "\"" + m_cppCompilerPath + "\""; // g++
		for (const auto& file : sourceFiles) {
			command += " \"" + file + "\"";
		}
		command += " -o \"" + outputFile + "\"";
	}
	else if (m_compilerType == VisualStudio) {
		// Visual Studio 编译命令
		command = "\"" + m_cCompilerPath + "\""; // cl.exe

		// 添加 C++ 异常处理选项
		command += " /EHsc";

		// 从环境变量获取 INCLUDE 路径并添加到命令
		std::string includePaths = GetEnvironmentVariableSafe("INCLUDE");
		if (!includePaths.empty()) {
			std::istringstream stream(includePaths);
			std::string path;
			while (std::getline(stream, path, ';')) {
				if (!path.empty()) {
					command += " /I\"" + path + "\"";
				}
			}
		}
		else {
			outputMessage += "Warning: INCLUDE environment variable is empty. Compilation may fail.\n";
		}

		// 添加源文件路径并为每个源文件生成对应的 .obj 文件
		for (const auto& file : sourceFiles) {
			std::string objFile = file;
			size_t pos = objFile.find_last_of('.');
			if (pos != std::string::npos) {
				objFile = objFile.substr(0, pos) + ".obj"; // 替换后缀为 .obj
			}
			else {
				objFile += ".obj"; // 默认添加 .obj 后缀
			}

			command += " \"" + file + "\" /Fo\"" + objFile + "\"";
		}

		// 添加调试信息（可选）
		command += " /Zi";
	}
	else {
		outputMessage = "Error: Unsupported compiler type.";
		return "";
	}

	return command;
}

std::string CompilerManager::BuildLinkCommand(const std::vector<std::string>& objectFiles, const std::string& outputFile, std::string& outputMessage) {
	std::string command;

	if (m_compilerType == MinGW) {
		// MinGW 链接命令
		command = "\"" + m_cppCompilerPath + "\""; // 使用 g++
		for (const auto& objFile : objectFiles) {
			command += " \"" + objFile + "\""; // 添加对象文件
		}
		command += " -o \"" + outputFile + "\""; // 指定输出文件
	}
	else if (m_compilerType == VisualStudio) {
		// Visual Studio 链接命令
		command = "\"" + m_linkerPath + "\""; // 使用 link.exe

		// 添加输入对象文件
		if (objectFiles.empty()) {
			outputMessage = "Error: No object files provided for linking.";
			return "";
		}
		for (const auto& objFile : objectFiles) {
			command += " \"" + objFile + "\"";
		}

		// 添加输出文件路径
		if (outputFile.empty()) {
			outputMessage = "Error: No output file specified.";
			return "";
		}
		command += " /OUT:\"" + outputFile + "\"";

		// 从环境变量获取 LIB 路径并添加到命令
		std::string libPaths = GetEnvironmentVariableSafe("LIB");
		if (!libPaths.empty()) {
			std::istringstream stream(libPaths);
			std::string path;
			while (std::getline(stream, path, ';')) {
				if (!path.empty()) {
					command += " /LIBPATH:\"" + path + "\"";
				}
			}
		}
		else {
			outputMessage = "Warning: LIB environment variable is empty. Linking may fail.";
		}

		// 添加默认库文件（例如常用的 runtime 库）
		command += " kernel32.lib user32.lib gdi32.lib";
	}

	return command;
}

// 执行编译命令
bool CompilerManager::ExecuteCompileCommand(const std::string& command, std::string& outputMessage) {
	STARTUPINFOA si;
	PROCESS_INFORMATION pi;
	ZeroMemory(&si, sizeof(si));
	si.cb = sizeof(si);
	ZeroMemory(&pi, sizeof(pi));

	// 创建一个缓冲区用于捕获输出
	HANDLE hReadPipe, hWritePipe;
	SECURITY_ATTRIBUTES sa = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE };
	if (!CreatePipe(&hReadPipe, &hWritePipe, &sa, 0)) {
		outputMessage = "Failed to create pipe.";
		return false;
	}

	// 重定向子进程的输出
	si.dwFlags |= STARTF_USESTDHANDLES;
	si.hStdOutput = hWritePipe;
	si.hStdError = hWritePipe;

	// 执行命令
	if (!CreateProcessA(
		NULL,
		(LPSTR)command.c_str(),
		NULL,
		NULL,
		TRUE,
		0,
		NULL,
		NULL,
		&si,
		&pi)) {
		outputMessage = "Failed to execute command.";
		CloseHandle(hReadPipe);
		CloseHandle(hWritePipe);
		return false;
	}

	// 关闭写入端句柄
	CloseHandle(hWritePipe);

	// 从管道中读取输出
	CHAR buffer[128];
	DWORD bytesRead;
	outputMessage.clear();
	while (ReadFile(hReadPipe, buffer, sizeof(buffer) - 1, &bytesRead, NULL)) {
		buffer[bytesRead] = '\0'; // 确保缓冲区以 NULL 结尾
		outputMessage += buffer;
	}

	// 等待子进程结束
	WaitForSingleObject(pi.hProcess, INFINITE);

	// 获取退出码
	DWORD exitCode;
	GetExitCodeProcess(pi.hProcess, &exitCode);

	// 关闭句柄
	CloseHandle(hReadPipe);
	CloseHandle(pi.hProcess);
	CloseHandle(pi.hThread);

	return exitCode == 0;
}
用c++创造编译器（Brainfuck）
thy21171的博客
10-11 1690
用c++创造Brainfuck的编译器 (自创代码)
用C++实现一个简单编译器
qq_73990157的博客
03-23 1106
主函数从输入文件中读取代码，进行语法分析，构建抽象语法树，生成目标代码，最后执行这些代码的过程。在LLVM中创建这个函数意味着你可以在你的LLVM的代码中使用。展示了如何构建一个抽象语法树（AST），并将其转换成LLVM中间表示（IR），然后编译和执行这些IR。这个函数演示了如何在LLVM中定义和使用自己的函数，以及如何调用其他函数（如。，从而在LLVM上下文中创建这些函数。准备好执行环境，然后运行主函数它接受一个空参数列表，并返回执行结果。这个函数的目的是在LLVM的上下文中创建一个代表。
在c++程序中调用被C编译器编译后的函数，为什么要使用extern “C”
05-04 8326
c/c++函数调用约定：c/c++函数调用约定 一、原题： 二、详细说明： 现在，在一个工程中；有一个test.c文件；一个test1.cpp文件；//test.c#include<stdio.h>int Add(int a,int b) { return a+b; } （1）使用extern int Add(int,int);声明外部函数—–错误 //test1.cpp#inc
c语言调用编译程序,用C++语言，调用标准C语言编译器编程的库
weixin_34567845的博客
05-18 229
当我们调用的函数实现是*.c，而不是*.cpp时，如果不注意，在Visual C++编译器中编译，会报错。error LNK2019，无法解析的外部符号“**************”(？*******)该符号在函数***中被引用。这是在C++中调用C的代码，我们必须对C的代码进行处理，才能给顺利通过。有三种方法：1、修改C代码的头文件，假设其头文件为Max.h，其调用的函数为int Max(in...
自己动手写一个编译器
热门推荐
weixin_55229531的博客
07-25 4万+
Pcode 是 TinyC 编译器的中间代码，是本人参考 pascal 编译器的中间代码 pcode 、并结合逆波兰表达式（后缀表达式）的逻辑后，设计出的一种非常简单的、基于栈和符号表的虚拟代码。Pcode 虚拟机是一个用来运行 Pcode 命令的、假想的机器，它包括：一个代码区（code）、一个指令指针（eip）、一个栈（stack）、一个变量表（var_table)、一个函数表（func_table）以及一个标签表（label_table）。
C++函数声明，自定义函数库调用
qq_64281750的博客
04-29 2452
函数和变量一样，定义和声明是可以分开的，我们一般将只需要包含函数原型的函数声明集中放在头文件中，然后通过预处理命令来调用自定义函数库中的函数，这样可以有效的避免函数重定义的问题。 函数的重定义 //函数的重定义 //作者：分解机226 #include <iostream> using namespace std; int bl(int a,int b) { return a + b; } int bl(int a, int b) { return a + b; } int main
C++编译器.7z
12-13
C++编译器是将C++源代码转换为可执行程序的关键工具，它是程序员与计算机硬件之间的桥梁。本节将详细介绍C++编译器及其在软件开发中的重要性。 1. **编译器的基本概念** 编译器是一种特殊的程序，它的主要任务是将...
WinCC调用自定义DLL.rar
12-04
本资源"WinCC调用自定义DLL.rar"提供了一个C++构建的DLL框架，使得用户可以将自己的控制模型或算法集成到WinCC中，实现更灵活、更个性化的控制逻辑。 首先，我们来理解什么是DLL。DLL（Dynamic Link Library）是...
举例说明自定义C++异常处理的实例
08-29
自定义C++异常处理允许程序员创建自己的异常类型，以便更精确地控制程序的错误处理方式。 在第一个例子中，我们创建了一个名为`myException`的自定义异常类，它是C++标准库中的`exception`类的子类。`myException`...
(matlab调用c++函数)Matlab 添加 c++ 自定义支持库，让matlab也能使用c++的函数
最新发布
yourgrandfa的博客
12-26 672
Matlab 是强大的数据处理算法工具，但软件功能方面存在欠缺。对于常使用 Matlab 跑算法且对其软件能力不满的用户，可采用特定方法将自定义的 C++ 函数融入 Matlab 软件项目中，以解决如多线程池（因 Matlab 线程池的许可证检查机制导致开启慢）、网络通讯等问题。
Java 面对对象（下）
QHBfuture的博客
07-03 1289
面向对象
如何在MATLAB中调用现有的c/c++编译器
预备的小小CV算法工程师
09-25 1562
如果matlab的编译器配置错误，则会出现以下报错： mbuild -setup Unable to complete successfully. 此时就需要我们手动给Matlab配置编译器 首先需要确定，我们的编译器路径 比如我这里是用QT的编译器，所以要先找到位置 并且确保该路径在系统环境变量中 之后进入matlab，在下方的命令行中配置环境 setenv(‘MW_MINGW64_LOC’, ‘D:\qt5\Tools\mingw810_64’); 此时调用mex -setup，则会提示已
C++ 学习之旅（1）——编译器Compiler
自动化研究生在读，此博客记录了我的学习与刷题经验，欢迎大家阅读交流
09-26 1794
简单来说，由C++代码文件生成可执行文件的过程如下： #mermaid-svg-PrvRlfwbvN6vbLVm .label{font-family:'trebuchet ms', verdana, arial;font-family:var(--mermaid-font-family);fill:#333;color:#333}#mermaid-svg-PrvRlfwbvN6vbLVm .label text{fill:#333}#mermaid-svg-PrvRlfwbvN6vbLVm .node r
c++ 编译器_C｜编译器是如何实现函数调用的？
weixin_39620099的博客
11-23 1028
任何编程语言，函数都是很重要的一个概念。算法要借助函数来实现。面向过程编程的函数是其基本模块。面向对象编程的函数(方法)是类或对象对其属性(数据的处理)。函数式编程自然更是以函数为核心。通常，程序的控制结构会确保一个入口、一个出口，支持函数的嵌套调用。如何确保代码的正确流动(包括正确返回原函数调用处)？编译器会维护一个栈的内存结构。另外，关于堆栈平衡，可由调用函数负责，也可由被调函数负责。当有多个...
如何在C++中调用C程序？
享之
11-04 2万+
C＋＋和C是两种完全不同的编译链接处理方式，如果直接在C＋＋里面调用C函数，会找不到函数体，报链接错误。要解决这个问题，就要在 C＋＋文件里面显示声明一下哪些函数是C写的，要用C的方式来处理。 1.引用头文件前需要加上 extern “C”，如果引用多个，那么就如下所示 extern “C” { #include “ s.h” #include “t.h” #include “g.h”
C++——编译器运行过程
weixin_33724659的博客
06-16 879
C++ 编译过程简介 C/C++程序编译流程: 预处理->编译->汇编->链接 具体的就是： 源代码（source coprede）→预处理器（processor）→编译器（compiler）→汇编程序（assembler）→目标程序（object code）→链接器（Linker）→可执行程序（executables） C语言在linux下的基本流程如图...
Java编译原理与自定义语言编译器实现
例如，GCC是用于将C/C++代码转换为机器码的编译器，而Java编译器则是将Java源代码编译成Java虚拟机能够执行的字节码。 3. 自定义编译器功能: 为了使编译器易于理解和实现，本项目中的编译器仅支持有限的功能。这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值