纯C++ 简单图色对比灵敏度低的问题

为何这么做：想用C++实现已知模板的简单图色对比，以用于自动化。
不用C++调用pyautogui ，并且需要安装python环境，无法独立运行。
问题：下列我给出的代码可以识别匹配，但是阈值有点低。我用相同函数截取出的两张图，
并且对比图基本是从模板图上选取的一部分，但是识别不出。
需求：通过改进算法或者优化代码以提高识别的灵敏度，在高阈值下仍可准确识别。
或者有一个方便快捷且无需python环境调用pyautogui的方法也可以
截图代码如下：


#include <windows.h>
#include <chrono>
#include <thread>
#include <string>
#include <cwchar>
#include <iostream>
#include <cassert> // 引入assert宏

HDC g_hCompatibleDC = nullptr;
HBITMAP g_hBitmap = nullptr;

// 保存bmp图片
BOOL SaveBitmap(HBITMAP hBitmap, LPCWSTR filename)
{
    HDC hDC;
    int iBits;
    WORD wBitCount;
    DWORD dwPaletteSize = 0, dwBmBitsSize = 0, dwDIBSize = 0, dwWritten = 0;
    BITMAP Bitmap;
    BITMAPFILEHEADER bmfHdr;
    BITMAPINFOHEADER bi;
    LPBITMAPINFOHEADER lpbi;
    HANDLE fh, hDib, hPal, hOldPal = NULL;

    // 获取位图信息
    hDC = CreateDC(L"DISPLAY", NULL, NULL, NULL);
    iBits = GetDeviceCaps(hDC, BITSPIXEL) * GetDeviceCaps(hDC, PLANES);
    DeleteDC(hDC);
    if (iBits <= 1)
        wBitCount = 1;
    else if (iBits <= 4)
        wBitCount = 4;
    else if (iBits <= 8)
        wBitCount = 8;
    else
        wBitCount = 24;

    GetObject(hBitmap, sizeof(Bitmap), (LPSTR)&Bitmap);
    bi.biSize = sizeof(BITMAPINFOHEADER);
    bi.biWidth = Bitmap.bmWidth;
    bi.biHeight = Bitmap.bmHeight;
    bi.biPlanes = 1;
    bi.biBitCount = wBitCount;
    bi.biCompression = BI_RGB;
    bi.biSizeImage = 0;
    bi.biXPelsPerMeter = 0;
    bi.biYPelsPerMeter = 0;
    bi.biClrImportant = 0;
    bi.biClrUsed = 256;

    dwBmBitsSize = ((Bitmap.bmWidth * wBitCount + 31) / 32) * 4 * Bitmap.bmHeight;

    // 创建位图的一个副本
    hDib = GlobalAlloc(GHND, dwBmBitsSize + dwPaletteSize + sizeof(BITMAPINFOHEADER));
    lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDib);
    *lpbi = bi;

    hPal = GetStockObject(DEFAULT_PALETTE);
    if (hPal) {
        hDC = GetDC(NULL);
        hOldPal = SelectPalette(hDC, (HPALETTE)hPal, FALSE);
        RealizePalette(hDC);
    }

    // 获取位图数据
    if (!GetDIBits(hDC, hBitmap, 0, (UINT)Bitmap.bmHeight,
        (LPSTR)lpbi + sizeof(BITMAPINFOHEADER) + dwPaletteSize,
        (BITMAPINFO*)lpbi, DIB_RGB_COLORS)) {
        MessageBox(NULL, L"GetDIBits failed", L"Error", MB_ICONERROR);
        GlobalUnlock(hDib);
        GlobalFree(hDib);
        return FALSE;
    }

    if (hOldPal) {
        SelectPalette(hDC, (HPALETTE)hOldPal, TRUE);
        RealizePalette(hDC);
        ReleaseDC(NULL, hDC);
    }

    // 创建位图文件
    fh = CreateFileW(filename, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
        FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, NULL);

    if (fh == INVALID_HANDLE_VALUE) {
        MessageBox(NULL, L"CreateFile failed", L"Error", MB_ICONERROR);
        GlobalUnlock(hDib);
        GlobalFree(hDib);
        return FALSE;
    }

    // 设置位图文件头
    bmfHdr.bfType = 0x4D42; // "BM"
    dwDIBSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwPaletteSize + dwBmBitsSize;
    bmfHdr.bfSize = dwDIBSize;
    bmfHdr.bfReserved1 = 0;
    bmfHdr.bfReserved2 = 0;
    bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER) + dwPaletteSize;

    // 写入位图文件头
    WriteFile(fh, (LPSTR)&bmfHdr, sizeof(BITMAPFILEHEADER), &dwWritten, NULL);

    // 写入位图信息头
    WriteFile(fh, (LPSTR)lpbi, sizeof(BITMAPINFOHEADER) + dwPaletteSize, &dwWritten, NULL);

    // 写入位图数据
    WriteFile(fh, (LPSTR)lpbi + sizeof(BITMAPINFOHEADER) + dwPaletteSize, dwBmBitsSize, &dwWritten, NULL);

    // 清理
    GlobalUnlock(hDib);
    GlobalFree(hDib);
    CloseHandle(fh);

    return TRUE;
}

void CaptureScreenRegion(HWND hWnd, int x, int y, int width, int height, const std::wstring& filename /*= L"Screenshots.bmp"*/)
{
    HDC hWindowDC = GetWindowDC(hWnd);
    HDC hMemDC = CreateCompatibleDC(NULL);
    HBITMAP hBitmap = CreateCompatibleBitmap(hWindowDC, width, height);
    SelectObject(hMemDC, hBitmap);

    // 将窗口内容的指定部分复制到兼容的内存DC中
    BitBlt(hMemDC, 0, 0, width, height, hWindowDC, x, y, SRCCOPY);

    ReleaseDC(hWnd, hWindowDC);

    // 将内存中的位图保存到文件
    if (!SaveBitmap(hBitmap, filename.c_str())) {
        std::wcerr << L"Failed to save bitmap to: " << filename << std::endl;
    }

    // 清理局部资源
    DeleteObject(hBitmap);
    DeleteDC(hMemDC);
}

int main()
{
    HWND hwnd = FindWindow(NULL, L"游戏"); //指定窗口名字
    if (hwnd) {
        int startX = 400, startY = 400; // 起始坐标
        int captureWidth = 300, captureHeight = 300; // 截取宽度和高度

        // 直接调用CaptureScreenRegion函数进行屏幕截取，不需要额外的资源管理
        CaptureScreenRegion(hwnd, startX, startY, captureWidth, captureHeight, L"德玛西亚.bmp");

        // 无需额外的资源清理，因为CaptureScreenRegion内部已经处理
    }
    else {
        MessageBox(NULL, L"Cannot find window", L"Error", MB_ICONERROR);
    }

    return 0;
}

对比代码如下：

#include <iostream>
#include <vector>
#include <cmath>
#include <fstream>
#include <thread>
#include <mutex>
#define NOMINMAX
#include <windows.h>

// 使用 std::vector 存储图像数据，每个元素代表一个像素的灰度值
typedef std::vector<double> Image;

// 加载 BMP 文件
Image loadBMP(const std::string& filename, int& width, int& height) {
    std::ifstream file(filename, std::ios::binary); // 以二进制模式打开文件
    if (!file) {
        std::cerr << "Error: Failed to open file." << std::endl;
        throw std::runtime_error("Failed to open file.");
    }

    BITMAPFILEHEADER bmfHdr; // BMP 文件头
    file.read(reinterpret_cast<char*>(&bmfHdr), sizeof(bmfHdr));
    if (bmfHdr.bfType != 0x4D42) { // 检查文件类型是否为 BMP
        std::cerr << "Error: Not a valid BMP file." << std::endl;
        throw std::runtime_error("Not a valid BMP file.");
    }

    BITMAPINFOHEADER bi; // BMP 信息头
    file.read(reinterpret_cast<char*>(&bi), sizeof(bi));
    if (bi.biBitCount != 24) { // 支持 24 位颜色深度的 BMP 文件
        std::cerr << "Error: Unsupported BMP format." << std::endl;
        throw std::runtime_error("Unsupported BMP format.");
    }

    width = bi.biWidth;
    height = bi.biHeight;
    std::cout << "Loaded image with dimensions: " << width << "x" << height << std::endl; // 输出图像尺寸

    file.seekg(bmfHdr.bfOffBits); // 移动文件指针到像素数据起始位置
    Image imageData(width * height); // 创建图像数据向量
    for (int y = height - 1; y >= 0; --y) { // 从下往上读取像素
        for (int x = 0; x < width; ++x) {
            unsigned char blue, green, red; // 分别读取 BGR 值
            file.read(reinterpret_cast<char*>(&blue), 1);
            file.read(reinterpret_cast<char*>(&green), 1);
            file.read(reinterpret_cast<char*>(&red), 1);
            imageData[y * width + x] = 0.2989 * red + 0.5870 * green + 0.1140 * blue; // 计算灰度值
        }
        if ((width * 3) % 4 != 0) { // 行尾可能有填充字节
            file.ignore(4 - (width * 3) % 4);
        }
    }

    return imageData;
}

// 结构体用于存储归一化互相关 (NCC) 的统计信息
struct NccStats {
    double sum1, sum2, sumSquare1, sumSquare2, sumProduct;
    int size;
};

// 更新统计信息，当滑动窗口移动时调用
void updateStats(NccStats& stats, double newPixel, double oldPixel, int width) {
    stats.sum1 += newPixel - oldPixel;
    stats.sumSquare1 += newPixel * newPixel - oldPixel * oldPixel;
    stats.sumProduct += newPixel * stats.sum2 / stats.size - oldPixel * stats.sum2 / stats.size;
}

// 计算 NCC 值
double calculateNCC(const NccStats& stats) {
    double denom = std::sqrt((stats.sumSquare1 - stats.sum1 * stats.sum1 / stats.size) *
        (stats.sumSquare2 - stats.sum2 * stats.sum2 / stats.size));
    return denom == 0 ? 0 : stats.sumProduct / denom;
}

// 结构体用于存储匹配信息，包括中心位置和得分
struct MatchInfo {
    std::pair<int, int> location; // 中心位置
    double score; // 匹配得分
};

// 在背景图像中查找模板的最佳匹配位置
MatchInfo findBestMatchSlidingWindowWithScore(const Image& background, const Image& templateImg,
    int bgWidth, int bgHeight, int tmplWidth, int tmplHeight,
    double threshold, int startX, int startY, int endX, int endY) {
    double bestScore = -1.0;
    std::pair<int, int> bestMatchLocation(-1, -1);

    NccStats stats;
    stats.size = tmplWidth * tmplHeight;
    for (int i = 0; i < stats.size; ++i) {
        stats.sum1 += templateImg[i];
        stats.sumSquare1 += templateImg[i] * templateImg[i];
    }

    for (int i = 0; i < stats.size; ++i) {
        stats.sum2 += templateImg[i];
        stats.sumSquare2 += templateImg[i] * templateImg[i];
    }

    for (int y = startY; y <= endY - tmplHeight; ++y) { // 遍历所有可能的y坐标
        for (int x = startX; x <= endX - tmplWidth; ++x) { // 遍历所有可能的x坐标
            if (x == startX) { // 第一次遍历初始化统计数据
                stats.sum1 = 0;
                stats.sumSquare1 = 0;
                for (int ty = 0; ty < tmplHeight; ++ty) {
                    for (int tx = 0; tx < tmplWidth; ++tx) {
                        double pixel = background[(y + ty) * bgWidth + (x + tx)];
                        stats.sum1 += pixel;
                        stats.sumSquare1 += pixel * pixel;
                    }
                }
            }
            else { // 更新统计数据，当窗口向右移动时
                int lastColumnIndex = (y + tmplHeight - 1) * bgWidth + x - 1;
                int nextColumnIndex = (y + tmplHeight - 1) * bgWidth + x + tmplWidth - 1;
                double oldPixel = background[lastColumnIndex];
                double newPixel = background[nextColumnIndex];
                updateStats(stats, newPixel, oldPixel, bgWidth);
            }

            double score = calculateNCC(stats); // 计算 NCC 得分

            if (score > bestScore && score >= threshold) { // 更新最佳匹配位置和得分
                bestScore = score;
                bestMatchLocation = { x, y };
            }
        }

        if (y < endY - tmplHeight) { // 更新统计数据，当窗口向下移动时
            for (int tx = 0; tx < tmplWidth; ++tx) {
                int index = y * bgWidth + tx;
                updateStats(stats, 0, background[index], bgWidth);
            }

            for (int tx = 0; tx < tmplWidth; ++tx) {
                int index = (y + tmplHeight) * bgWidth + tx;
                updateStats(stats, background[index], 0, bgWidth);
            }
        }
    }

    // 计算最佳匹配区域的中心坐标，并四舍五入
    int centerX = std::round(bestMatchLocation.first + static_cast<double>(tmplWidth) / 2);
    int centerY = std::round(bestMatchLocation.second + static_cast<double>(tmplHeight) / 2);

    return { { centerX, centerY }, bestScore }; // 返回最佳匹配信息，包含中心坐标
}

int main() {
    int bgWidth, bgHeight;
    Image backgroundImage = loadBMP("111111.bmp", bgWidth, bgHeight); // 加载背景图像
    std::cout << "Background image loaded successfully." << std::endl;

    std::vector<std::string> templateFilenames = { "222222.bmp" }; // 模板图像文件名

    double threshold = 0.1;
    std::vector<std::pair<int, int>> results;
    std::vector<double> scores;

    int startX = 10, startY = 10, endX = bgWidth - 20, endY = bgHeight - 20;
    std::cout << "Search area: (" << startX << ", " << startY << ") to (" << endX << ", " << endY << ")" << std::endl;

    for (const auto& filename : templateFilenames) { // 遍历所有模板图像
        int tmplWidth, tmplHeight;
        Image templateImg = loadBMP(filename, tmplWidth, tmplHeight); // 加载模板图像
        std::cout << "Template image loaded with dimensions: " << tmplWidth << "x" << tmplHeight << std::endl;

        auto matchInfo = findBestMatchSlidingWindowWithScore(backgroundImage, templateImg,
            bgWidth, bgHeight, tmplWidth, tmplHeight,
            threshold, startX, startY, endX, endY); // 查找最佳匹配

        // 更新存储结果的方式，现在matchInfo包含的是中心坐标
        results.push_back(matchInfo.location);
        scores.push_back(matchInfo.score);

        std::cout << "Match found at center: " << matchInfo.location.first << ", "
            << matchInfo.location.second << " with score: " << matchInfo.score << std::endl;
    }

    double maxScore = -1.0;
    std::pair<int, int> bestMatch;
    for (size_t i = 0; i < scores.size(); ++i) {
        if (scores[i] > maxScore) {
            maxScore = scores[i];
            bestMatch = results[i];
        }
    }

    if (bestMatch.first != -1 && bestMatch.second != -1) {
        std::cout << "The best match is at center location: (" << bestMatch.first << ", " << bestMatch.second << ")" << std::endl;
    }
    else {
        std::cout << "No good match found." << std::endl;
    }

    return 0;
}

写回答
好问题 0 提建议
追加酬金
关注问题
分享
邀请回答
编辑收藏删除
收藏举报

14条回答默认最新

杨同学* 2024-08-07 09:04

关注

该回答结合ChatGPT4o及杨同学*共同作答, 如有帮助，还请采纳。
为了提高图像比较算法的灵敏度，我们可以对现有的C++代码进行一些改进。以下是一些可能的步骤：

改进图像比较算法的步骤

改进图像比较算法:
- 使用更为先进的图像比较技术，例如结构相似性指数(SSIM) 或其他比简单像素对像素比较更为稳健的方法。
- 在比较之前确保图像数据的正确归一化。
优化代码:
- 确保捕获的图像以足够高的分辨率进行处理。
- 如果图像尺寸较大，使用多线程或并行处理以加快图像比较的速度。
高效地加载和保存图像:
- 确保BMP文件的读取和写入操作高效且无错误。

更新后的C++代码

下面是改进的C++代码示例，使用标准化的交叉相关（NCC）来进行更敏感的图像比较：

#include <iostream>
#include <vector>
#include <cmath>
#include <fstream>
#include <thread>
#include <mutex>
#define NOMINMAX
#include <windows.h>

// 使用std::vector存储图像数据，每个元素表示一个像素的灰度值
typedef std::vector<double> Image;

// 加载BMP文件
Image loadBMP(const std::string& filename, int& width, int& height) {
    std::ifstream file(filename, std::ios::binary);
    if (!file) {
        std::cerr << "错误: 无法打开文件。" << std::endl;
        throw std::runtime_error("无法打开文件。");
    }

    BITMAPFILEHEADER bmfHdr;
    file.read(reinterpret_cast<char*>(&bmfHdr), sizeof(bmfHdr));
    if (bmfHdr.bfType != 0x4D42) {
        std::cerr << "错误: 不是有效的BMP文件。" << std::endl;
        throw std::runtime_error("不是有效的BMP文件。");
    }

    BITMAPINFOHEADER bi;
    file.read(reinterpret_cast<char*>(&bi), sizeof(bi));
    if (bi.biBitCount != 24) {
        std::cerr << "错误: 不支持的BMP格式。" << std::endl;
        throw std::runtime_error("不支持的BMP格式。");
    }

    width = bi.biWidth;
    height = bi.biHeight;
    std::cout << "加载的图像尺寸: " << width << "x" << height << std::endl;

    file.seekg(bmfHdr.bfOffBits);
    Image imageData(width * height);
    for (int y = height - 1; y >= 0; --y) {
        for (int x = 0; x < width; ++x) {
            unsigned char blue, green, red;
            file.read(reinterpret_cast<char*>(&blue), 1);
            file.read(reinterpret_cast<char*>(&green), 1);
            file.read(reinterpret_cast<char*>(&red), 1);
            imageData[y * width + x] = 0.2989 * red + 0.5870 * green + 0.1140 * blue;
        }
        if ((width * 3) % 4 != 0) {
            file.ignore(4 - (width * 3) % 4);
        }
    }

    return imageData;
}

// 标准化交叉相关（NCC）统计信息结构
struct NccStats {
    double sum1, sum2, sumSquare1, sumSquare2, sumProduct;
    int size;
};

// 滑动窗口移动时更新统计信息
void updateStats(NccStats& stats, double newPixel, double oldPixel, int width) {
    stats.sum1 += newPixel - oldPixel;
    stats.sumSquare1 += newPixel * newPixel - oldPixel * oldPixel;
    stats.sumProduct += newPixel * stats.sum2 / stats.size - oldPixel * stats.sum2 / stats.size;
}

// 计算NCC值
double calculateNCC(const NccStats& stats) {
    double denom = std::sqrt((stats.sumSquare1 - stats.sum1 * stats.sum1 / stats.size) *
                             (stats.sumSquare2 - stats.sum2 * stats.sum2 / stats.size));
    return denom == 0 ? 0 : stats.sumProduct / denom;
}

// 存储匹配信息的结构，包括中心位置和得分
struct MatchInfo {
    std::pair<int, int> location; // 中心位置
    double score; // 匹配得分
};

// 在背景图像中找到模板的最佳匹配位置
MatchInfo findBestMatchSlidingWindowWithScore(const Image& background, const Image& templateImg,
                                              int bgWidth, int bgHeight, int tmplWidth, int tmplHeight,
                                              double threshold, int startX, int startY, int endX, int endY) {
    double bestScore = -1.0;
    std::pair<int, int> bestMatchLocation(-1, -1);

    NccStats stats;
    stats.size = tmplWidth * tmplHeight;
    for (int i = 0; i < stats.size; ++i) {
        stats.sum1 += templateImg[i];
        stats.sumSquare1 += templateImg[i] * templateImg[i];
    }

    for (int i = 0; i < stats.size; ++i) {
        stats.sum2 += templateImg[i];
        stats.sumSquare2 += templateImg[i] * templateImg[i];
    }

    for (int y = startY; y <= endY - tmplHeight; ++y) {
        for (int x = startX; x <= endX - tmplWidth; ++x) {
            if (x == startX) {
                stats.sum1 = 0;
                stats.sumSquare1 = 0;
                for (int ty = 0; ty < tmplHeight; ++ty) {
                    for (int tx = 0; tx < tmplWidth; ++tx) {
                        double pixel = background[(y + ty) * bgWidth + (x + tx)];
                        stats.sum1 += pixel;
                        stats.sumSquare1 += pixel * pixel;
                    }
                }
            } else {
                int lastColumnIndex = (y + tmplHeight - 1) * bgWidth + x - 1;
                int nextColumnIndex = (y + tmplHeight - 1) * bgWidth + x + tmplWidth - 1;
                double oldPixel = background[lastColumnIndex];
                double newPixel = background[nextColumnIndex];
                updateStats(stats, newPixel, oldPixel, bgWidth);
            }

            double score = calculateNCC(stats);

            if (score > bestScore && score >= threshold) {
                bestScore = score;
                bestMatchLocation = { x, y };
            }
        }

        if (y < endY - tmplHeight) {
            for (int tx = 0; tx < tmplWidth; ++tx) {
                int index = y * bgWidth + tx;
                updateStats(stats, 0, background[index], bgWidth);
            }

            for (int tx = 0; tx < tmplWidth; ++tx) {
                int index = (y + tmplHeight) * bgWidth + tx;
                updateStats(stats, background[index], 0, bgWidth);
            }
        }
    }

    int centerX = std::round(bestMatchLocation.first + static_cast<double>(tmplWidth) / 2);
    int centerY = std::round(bestMatchLocation.second + static_cast<double>(tmplHeight) / 2);

    return { { centerX, centerY }, bestScore };
}

int main() {
    int bgWidth, bgHeight;
    Image backgroundImage = loadBMP("111111.bmp", bgWidth, bgHeight);
    std::cout << "背景图像加载成功。" << std::endl;

    std::vector<std::string> templateFilenames = { "222222.bmp" };

    double threshold = 0.1;
    std::vector<std::pair<int, int>> results;
    std::vector<double> scores;

    int startX = 10, startY = 10, endX = bgWidth - 20, endY = bgHeight - 20;
    std::cout << "搜索区域: (" << startX << ", " << startY << ") 到 (" << endX << ", " << endY << ")" << std::endl;

    for (const auto& filename : templateFilenames) {
        int tmplWidth, tmplHeight;
        Image templateImg = loadBMP(filename, tmplWidth, tmplHeight);
        std::cout << "模板图像加载尺寸: " << tmplWidth << "x" << tmplHeight << std::endl;

        auto matchInfo = findBestMatchSlidingWindowWithScore(backgroundImage, templateImg,
            bgWidth, bgHeight, tmplWidth, tmplHeight,
            threshold, startX, startY, endX, endY);

        results.push_back(matchInfo.location);
        scores.push_back(matchInfo.score);

        std::cout << filename << "最佳匹配位置: (" << matchInfo.location.first << ", " << matchInfo.location.second << ")"
                  << "，得分: " << matchInfo.score << std::endl;
    }

    std::cout << "所有模板图像处理完成。" << std::endl;
    return 0;
}

说明

图像加载: 这个更新的代码处理BMP图像加载和灰度值转换。
标准化交叉相关(NCC): `findBest

MatchSlidingWindowWithScore`函数现在使用NCC进行匹配，考虑了归一化以提高灵敏度。
3. 多线程: 可以通过并行化滑动窗口操作提高效率，特别是处理大图像时。

运行代码

确保BMP图像（111111.bmp 和 222222.bmp）在与C++文件相同的目录中。
使用支持C++11的编译器编译C++代码。
运行编译后的可执行文件。

这些更改应能提高图像比较过程的灵敏度和性能。

报告相同问题？

关注问题

C++语言编程子集和问题（回溯法解）注意用C++啊 c++
2018-05-01 15:55

回答 2 已采纳 ``` #include #include #include #include using namespace std; int n,c,a[10000],b
C++语言编程最大子段和 c++
2018-04-18 06:49

回答 4 已采纳 ``` 也可以用DP #include #include int main() { int count; int a[100];
C++语言编程检查一个3位数是水仙花数 c++
2018-10-11 00:03

回答 8 已采纳 ``` #include using namespace std; int main() { int a, b, c, y, n = 0; cout > n;
SIMGUI c++ python代码查重免安装版
2024-04-24 18:23

SIMGUI是一款基于Electron框架和Element UI库开发的代码查重工具，专为C++和Python编程语言设计。它利用了名为SIM的开源软件作为其核心算法，为用户提供了一个直观且用户友好的图形用户界面（GUI），使得代码相似性...
C++编程问题请大神赐教 c++
2018-07-19 03:14

回答 5 已采纳 ![图片说明](https://img-ask.csdn.net/upload/201807/19/1531970866_893372.gif) ``` // Q695122.cpp
C++的连接打印机显示图片的问题 c++
2018-07-20 08:19

回答 4 已采纳你这个肯定打印不出图形，你用的是esc/pos指令集，这种底层的方式只能打印文本。如果用这种方式要打印图像，需要自己计算像素点，转换为打印指令，再输出，不是一般的麻烦。正确的做法是安装好打
C++语言编程单调递增最长子序列 c++ 算法
2018-04-16 14:18

回答 2 已采纳参考：https://blog.csdn.net/lucienduan/article/details/24397949 ``` /*****************************
C++多线程管理的艺术：从基础到设计模式
2023-12-16 16:55

泡沫o0的博客线程管理包括线程的创建、同步、调度和销毁。在 C++ 中，这通常涉及对操作系统底层的调用。例如，使用 POSIX 线程（pthread）库在 Linux 系统中创建和管理线程，或者使用 C++11 提供的线程库。
C++语言编程结合两个字符串 c++
2018-10-10 23:48

回答 2 已采纳 #include #include using namespace std; string StrCon(const string& a, const string& b) { strin
C++语言编程运用贪心算法的方法 c++ 算法
2018-04-25 07:50

回答 4 已采纳 #include using namespace std; void print(int *a,int len) { int i=0; for(;i=right) return; int
C++语言编程急急！！！用分治策略 c++ 算法
2018-03-28 08:25

回答 2 已采纳 ``` #include void swap(int a[], int i, int j) { // 交换数组a中元素i与元素j的值 int tmp; tm
文件对比软件WinMerge
2022-07-15 15:11

4. 自定义设置：用户可以根据需求调整对比的灵敏度，例如忽略空格或换行符的差异，或者设置特定的字符匹配规则。此外，还能配置界面语言、字体大小和颜色主题等，以适应不同的工作环境。 5. 快捷操作：WinMerge提供...
C++编程问题请大神赐教谢谢 c++
2018-07-20 09:15

回答 5 已采纳 int c; if (n ==1||c == 2 ) 没有初始化就用了 c
克服边界：在C++中兼容C语言风格的函数指针回调的方式
2024-03-27 22:48

泡沫o0的博客通过对比和分析，读者可以更好地理解回调函数在不同编程语言中的实现方式和它们的内在联系。第二章: C语言回调函数的基本理解 2.1 定义回调函数回调函数（Callback Functions）在C语言中是一种通过函数指针...
常用的编程语言介绍以及各语言的特点（前端，前端框架，后端）
2019-03-28 09:47

xinyuxinwu的博客常用的编程语言介绍以及各语言的特点 编程语言（programming language），是用来定义计算机程序的形式语言。它是一种被标准化的交流技巧，用来向计算机发出指令。一种计算机语言让程序员能够准确地定义计算机所需要...
没有解决我的问题, 去提问

问题事件

关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
已结题（查看结题原因） 8月8日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
修改了问题 8月6日
关注

码龄粉丝数原力等级 --

被采纳

被点赞

采纳率
创建了问题 8月6日

悬赏问题

¥15 软件工程用例图的建立（相关搜索：软件工程用例图|画图）
¥15 如何在arcgis中导出拓扑关系表
¥15 处理数据集文本挖掘代码
¥15 matlab2017
¥15 在vxWorks下TCP/IP编程，总是connect（）报错，连接服务器失败: errno = 0x41
¥15 AnolisOs7.9如何安装 Qt_5.14.2的运行库
¥20 求：怎么实现qt与pcie通信
¥50 前后端数据顺序不一致问题，如何解决？（相关搜索：数据结构）
¥15 基于蒙特卡罗法的中介效应点估计代码
¥15 罗技G293和UE5.3

纯C++ 简单图色对比 灵敏度低的问题

14条回答 默认 最新