小编Ted*_*gmo的帖子

对于上下文，这是从引导加载程序调用的代码，该引导加载程序应引导到主应用程序中。该代码段来自带有参数的函数，该参数uintptr_t address指定了写入主应用程序的地址。我相信sp和pc分别是堆栈指针和程序计数器。

这是代码：

sp = *((void **)address + 0);
pc = *((void **)address + 1);
start_new_application(sp, pc);

这里的完整上下文

然后我走了，打印了地址，sp和pc，发现了以下内容：

address -> 0x08010000
sp ------> 0x20050000
pc ------> 0x080132DD

这让我很困惑。我不确定为什么该sp行中有一个+ 0。该sp行可以改写为：

sp = (void *)address;

并做同样的事情？

我的理解是，该地址已被static_casted为一个double void指针，然后sp被赋予地址的解除引用值（0x08010000），并pc已被赋予地址的解除引用值（0x08010001）。然后，在我的printf语句中，显示的这些值是这些地址的取消引用的值。

我的理解在这里正确吗？

我尝试使用以下线程中的解决方案在具有固定大小的类中创建向量向量，但无济于事。使用 boost 分配初始化具有固定大小的向量的向量

由于它已有 7 年历史，我认为这可能与 C++17 的变化有关，但我不确定问题出在哪里。IDE 告诉我的错误是第一个参数上的“预期类型说明符”。查看构造函数的文档，似乎没有什么问题，除非我错过了一些东西。

class SudokuSolver {

public:
    SudokuSolver() {}

    ~SudokuSolver() {}

private:
    std::vector<std::vector<int>> sudoku_field(9, std::vector<int>(9, 0));
};

我已经使用 cpp 很长一段时间了，我知道我们不能添加字符串和数字（​​因为 + 运算符没有为此重载）。但是，我看到了这样的代码。

#include <iostream>
using namespace std;
int main() {
    string a = "";
    a += 97;
    cout << a;
}

这输出'a'，我也试过这个。

string a ="";
a=a+97;

第二个代码给出了一个编译错误（作为 + 运算符std::string和 的无效参数 int）。我不想连接字符串和数字。有什么不同？为什么一个有效，而另一个无效？

我原以为a+=97是一样的，a=a+97但它似乎不同。

C++03 标准是否允许将 a 附加std::vector到自身？v我想知道如果需要重新分配内存，源迭代器是否会变得无效。在我的 STL 实现中，旧内存会一直保留，直到创建新内存为止。但我可以依靠这个吗？如果不是，v.reserve(2 * v.size())在插入之前是否是完全避免重新分配的良好解决方案？

vector<int> v;
v.reserve(3);
v.push_back(1);
v.push_back(2);
v.push_back(3);
// v may need to reallocate because its capacity may be less than 6.
// Is this operation safe?
v.insert(v.end(), v.cbegin(), v.cend());

或者

// Here v will _not_ need to reallocate because it has enough capacity.
// Is this operation safe?
v.reserve(2 * v.size());
v.insert(v.end(), v.cbegin(), v.cend());

我正在为 3ds 开发一款游戏，我希望它是一款 cmd 类型的游戏（我只是觉得喜欢）。我试图让这个 char 移动到我拥有的任何 x 和 y int 数字，但出现错误。这是我的代码。

/*
    Hello World example made by Aurelio Mannara for libctru
    This code was modified for the last time on: 12/12/2014 21:00 UTC+1
*/

#include <3ds.h>
#include <stdio.h>
#include <string.h>
int main(int argc, char **argv)
{
    gfxInitDefault();

    char player[1024] = "\x1b[";
    int tesx = 1;
    char tesxx = tesx + '0';
    char ot[] = ";";
    char oty[] = "H0";
    int test = 3;
    char testt = test + '0'; …

让我们假设如下：

我在 Linux / Mac OS 上有两个进程。

我有mmap共享内存（或在文件中）。

然后在这两个过程中我都有以下内容：

struct Data{
   volatile int reload = 0; // using int because is more standard
   // more things in the future...
};
void *mmap_memory = mmap(...);
Data *data = static_cast<Data *>(mmap_memory); // suppose size is sufficient and all OK

然后在我做的其中一个过程中：

//...
data->reload = 1;
//...

在另一个我做的：

while(...){
    do_some_work();
    //...
    if (data->reload == 1)
        do_reload();
}

这会是线程/进程间安全的吗？

想法来自这里：
https://embeddedartistry.com/blog/2019/03/11/improve-volatile-usage-with-volatile_load-and-volatile_store/

注意：
这对于 来说并不安全std::atomic<>，因为它不“承诺”有关共享内存的任何内容。此外，从两个不同的过程构建/销毁根本不清楚。

我正在开发我的第一个 arduino 项目，在那里我遇到了以下我想理解的行为。以下代码编译没有问题：

enum TestEnum {TestValue1};
void test(){}
void setup(){}
void loop(){}
void foo(TestEnum &testArg) {}

但交换前两行

void test(){}
enum TestEnum {TestValue1};
void setup(){}
void loop(){}
void foo(TestEnum &testArg) {}

编译时会出现以下错误：

D:\Path\to\Arduino-Sketches\foo\foo.ino:5:10: error: variable or field 'foo' declared void
 void foo(TestEnum &testArg) {}
          ^~~~~~~~
D:\Path\to\Arduino-Sketches\foo\foo.ino:5:10: error: 'TestEnum' was not declared in this scope
D:\Path\to\Arduino-Sketches\foo\foo.ino:5:10: error: note: suggested alternative: 'isalnum'
D:\Path\to\Arduino-Sketches\foo\foo.ino:5:20: error: 'testArg' was not declared in this scope
D:\Path\to\Arduino-Sketches\foo\foo.ino:5:20: error: note: suggested alternative: 'test'
 void foo(TestEnum &testArg) {}
                    ^~~~~~~
                    test …

std::format_args当我尝试与 一起使用时，出现 stack-use-after-scope 错误std::vformat()。重现它的简单代码是：

#include <format>
#include <iostream>
#include <string>

int main() {
    int i = 42;
    std::string s = "hello";
    std::format_args args = std::make_format_args(i, s);
    std::cout << std::vformat("Number: {}, Word: {}", args) << '\n';

    return 0;
}

我的i和s变量应该仍然在范围内并且不是右值，所以我不确定是什么触发了错误。如果我删除并直接在调用中args调用to ，一切都会按预期进行。我缺少什么？std::make_format_args()std::vformat()

这是我编译上述代码的命令：clang++-17 --std=c++23 -stdlib=libc++ -fsanitize=address fmt.cpp。

我正在尝试制作一个具有对象向量的类模板，并且能够在它们上运行对象类的功能，所以我不必循环抛出对象并运行该类，我可以像这样

allObjects.runFunc(objectsType::someFunc); 

在课堂上我想要3个命令：

• add -将项目添加到组中
• remove -删除物品
• runFunc(someFunc)-那是最重要的一个，我希望它someFunc在该组中的所有对象上 运行

并且该类将具有一个变量：
std::vector<Object> objects-将存储所有对象

所以我在互联网上看了很多，还没有找到我需要的东西，但是我尝试使用std :: bind并遇到了一些非常奇怪的故障。

类（在.h文件中）：

#pragma once
#include <vector>


template<class Object>
class Group {
public:
    void add(Object &object);
    void runFunc(void(Object::* func)(void));

private:
    std::vector<Object> objects;
};

template<class Object>
inline void Group<Object>::add(Object &object)
{
    objects.push_back(object);
}

template<class Object>
inline void Group<Object>::runFunc(void (Object::* func)(void))
{
    for (int i = 0; i < objects.size(); i++)
    {
        (objects[i].func)();
    }
}

我得到的错误是func不是gameObject的成员，其中gameobject是Im正在测试组的类型，是的，它确实具有更新功能。

template<class T>
struct E{};     //// no error


template<struct T>
struct F{};    ////error

错误：非类型模板参数不能具有类型“struct T”模板

如果除了默认和访问说明符之外，class和是相同的东西，那么为什么这不起作用？structprivatepublic