主页 / user-500890

Bloody.cpp's questions

Martin Hope
Bloody.cpp
Asked: 2022-09-01 18:14:47 +0000 UTC
  • 0

我正在制作自己的库，并决定使用宏对其进行配置。简单介绍一下问题：有2个类。BRange 和 BIndex。它们将在未来的类中用作参数（用于索引）。我还希望能够设置从 1 开始的索引。即：1 2 3 4 5，而不是 0 1 2 3 4。为此，我制作了 2 个宏，它们将采用 1 个参数（变量名）并将其带到常规索引。也就是说，如果启用了从 1 开始的索引，那么我只需从数字中减去 1 并获取索引。问题是这样的：出于某种原因，即使在打开此索引后，宏也总是与关闭时相同。我只是不知道该怎么处理它了。最初，我试图摆脱这样一个事实，即包含索引的宏具有一定的价值。在我复制了宏的名称之后，我可能会犯错。将此粘贴到 BIndex.h / Brange.h 文件中。（最初，我为此使用了另一个文件 - BConst.h）。很多次我看着没有逻辑错误。没有什么帮助。我扔掉了截图和项目档案的链接。

屏幕截图显示了我如何声明宏

在这里您可以看到如何声明用于索引的宏

但由于某种原因，宏仍然是错误的

而这个是一样的

如果有的话 - 这不是 IDE 错误。编译的时候，结果也是不正确的：

主文件

控制台输出

项目文件链接：https ://drive.google.com/file/d/1mPZuVgL4hEhMc0_xSGsgIqvB_KJboq9I/view?usp=sharing

c++ макросы
Martin Hope
Bloody.cpp
Asked: 2022-08-25 02:08:06 +0000 UTC
  • 1

想象这样一种情况，有一些函数接受一个参数并返回一个结果。在她的代码中，检查了这个参数的各种值。如果参数等于无效值，则会抛出异常。那么，异常后有必要写return吗？还是没有意义？

代码示例：

#include <iostream>
#include <exception>

using namespace std;

size_t checkpls(size_t value)
{
    if (value == 123)
    {
        throw exception("bad number((");
        return SIZE_MAX; // Нужно ли это?
    }
    cout << "all ok" << endl;
    return 23421;
}

int main()
{
    cout << checkpls(123);
    system("pause");
    return 1;
}
c++
Martin Hope
Bloody.cpp
Asked: 2022-07-20 01:11:27 +0000 UTC
  • 0

我正在编写一个类来分配内存并存储一块内存占用的字节数。它的工作原理是这样的：我们分配大小为 n + 8/4 (x64, x32) 的内存，其中 n 是所需的字节数。在这 8 个字节中，我们写入了内存块占用的字节数。移位 8 个字节，使用。

代码第 44 行出现异常：

0x6F6C6C6540，“读取访问冲突”

#include <iostream>
#include <vector>
#include <malloc.h>

using namespace std;

#ifdef _WIN64
    #define SIZEBLOCK_BYTES 8
#else
    #define SIZEBLOCK_BYTES 4
#endif

template<class T>
T* move_pointer_right(void* ptr, size_t bytes)
{
    return reinterpret_cast<T*>(reinterpret_cast<bool*>(ptr) + bytes);
}

template<class T>
T* move_pointer_left(void* ptr, size_t bytes)
{
    return reinterpret_cast<T*>(reinterpret_cast<bool*>(ptr) - bytes);
}

class BSmartheap
{
private:
    vector<void*>infoheap;
public:
    void* allocate_block(size_t sizeBytes);
    void free_memory(void* blockMem);
    size_t size_block(void* blockMem);
};

size_t BSmartheap::size_block(void* blockMem)
{
    const size_t sizevec = infoheap.size();
    for (size_t x = 0; x < sizevec; x++)
    {
        if (&infoheap[x] == blockMem)
        {
            return move_pointer_left<size_t>(infoheap[x], SIZEBLOCK_BYTES)[0]; // exception here
        }
    }
    return 0;
}

void BSmartheap::free_memory(void* blockMem)
{
    const size_t sizevec = infoheap.size();
    for (size_t x = 0; x < sizevec; x++)
    {
        if (&infoheap[x] == blockMem)
        {
            free(move_pointer_left<void>(infoheap[x], SIZEBLOCK_BYTES));
            infoheap.erase(infoheap.begin() + x);
            return;
        }
    }
}

void* BSmartheap::allocate_block(size_t sizeBytes)
{
    if (sizeBytes == 0)
    {
        throw exception("Size is null");
    }
    void* newPtr = malloc(sizeBytes + SIZEBLOCK_BYTES);
    if (newPtr == nullptr)
    {
        throw exception("malloc return nullptr");
    }
    reinterpret_cast<size_t*>(newPtr)[0] = sizeBytes;
    newPtr = move_pointer_right<void>(newPtr, SIZEBLOCK_BYTES);
    infoheap.push_back(newPtr);
    return &infoheap[infoheap.size() - 1];
}

static BSmartheap heap;

int main()
{
    char* ptr = reinterpret_cast<char*>(heap.allocate_block(6));
    const char* str = "Hello";
    for (size_t x = 0; x < 6; x++)
    {
        ptr[x] = str[x];
    }

    cout << ptr << endl;
    cout << heap.size_block(ptr) << endl;

    heap.free_memory(ptr);
    system("pause");
    return 1;
}
c++