我编写了以下非常简单的代码，我正在 godbolt 的编译器资源管理器中进行试验：
#include <cstdint>
uint64_t func(uint64_t num, uint64_t den)
{
return num / den;
}
GCC 产生以下输出，这是我所期望的：
func(unsigned long, unsigned long):
mov rax, rdi
xor edx, edx
div rsi
ret
然而 Clang 13.0.0 产生以下结果，涉及移位和跳转：
func(unsigned long, unsigned long): # @func(unsigned long, unsigned long)
mov rax, rdi
mov rcx, rdi
or rcx, rsi
shr rcx, 32
je .LBB0_1
xor edx, edx
div rsi
ret
.LBB0_1:
xor edx, edx
div esi
ret
当使用 uint32_t 时，clang 的输出再次“简单”并且符合我的预期。
这似乎可能是某种优化，因为 clang 10.0.1 产生与 GCC …
我喜欢 vcpkg 的想法，但我想我更愿意坚持使用 MinGW 作为我的编译器。
我找不到任何关于是否可以设置（或如何设置）vcpkg 以便它为 MinGW 而不是 MSVC 编译包的资源。如果可能的话，有人能给我指出正确的方向吗？
有一些关于此的主题，但它们没有明确的说明，而且我仍在学习这些东西。
谢谢！
我正在为 STM32 微控制器编写嵌入式程序。我希望能够将代表按钮的 GPIO 引脚存储在一个漂亮的、统一的结构中。
由于embedded-hal使用泛型对“Pin”结构的状态进行编码，因此每个GPIO都有不同的Rust类型，但是对于我的情况（按钮），它们都实现了embedded_hal::digital::v2::InputPin特征。
我可以明确指定每个成员的类型，但是在进行配置时我还必须为每个按钮编写引脚和端口，即：
let mut middle = gpioa
.pa6
.into_pull_up_input(&mut gpioa.moder, &mut gpioa.pupdr);
这意味着在结构中指定类型会导致冗余，如果我需要更改硬件中的引脚，我将需要在代码中的多个位置更改它。
存储这些引脚的规范方法是什么？当然，我不能使用特征对象，因为它位于嵌入式上下文中。
目前我有以下内容：
use embedded_hal::digital::v2::InputPin;
struct Buttons<M, R, L, U, D>
where
M: InputPin,
R: InputPin,
L: InputPin,
U: InputPin,
D: InputPin,
{
middle: M,
right: R,
left: L,
up: U,
down: D
}
然而，这似乎是潜在的代码味道。
另外，如果我想将此按钮结构存储在另一个结构中，则此父结构中的泛型数量很可能会非常大，除非我明确指定（因此写入两次）引脚类型。
有没有更好、更高效的方法？
C++ 标准建议 std::vector 呈指数增长，以便在重新分配方面具有“摊销不变成本”。
虽然这种类型的增长适用于大多数场景，但可能有一种情况我发现我需要使用不同的算法来增长向量。
有没有办法自定义 std::vector 的增长方式以及它在重新分配之前检查的条件？
我想要一个批处理文件来检查服务"MyServiceName"是否正在运行.如果服务正在运行,我希望批处理文件禁用它,然后显示一条消息.如果它没有运行,并且被禁用,我希望批处理文件显示一条消息,然后退出.谢谢您的帮助.
我发现很多关于不可变到可变的问题，但不太确定我在这段代码中做错了什么。
我收到的错误是：“不能values作为不可变的借用，因为它也作为可变的借用”
fn modify_vec_get_slice(values: &mut Vec<i32>) -> &[i32] {
// Modify "values" in some way
values.push(5);
// Return a slice into "values" (dummy code)
values.split_at(values.len() / 2).1
}
fn use_slice(slice: &[i32]) {
// Do something immutably with the slice
}
fn use_vec(values: &Vec<i32>) {
// Do something immutably with the vec
}
fn main() {
let mut values = vec![1, 2, 3, 4];
let slice = modify_vec_get_slice(&mut values); // use values mutably
use_vec(&values); // Error here is "&values" …我不太清楚为什么 Visual Studio 会给我以下代码的错误消息“错误定义的 for 循环：'unsigned int' 值始终在 '0' 到 '4294967295' 范围内。循环无限执行”：
for (unsigned int i = list->GetCount() - 1; i >= 0; i--)
{
// do stuff to each item (specifically in reverse order)
}
有人可以向我解释一下吗？
编辑： GetCount() 返回一个无符号整数，我无法控制它
假设我有一个简单的类，它将用户的朋友存储在字符串的 ArrayList 中，并使用 getter 访问该 ArrayList：
public class User
{
private ArrayList<String> mFriends;
// ...other code like constructors and setters...
public ArrayList<String> getFriends()
{
return mFriends;
}
}
由于 Java 和许多其他语言（等效地）是按引用传递的，这是否不允许 getFriends() 的调用者直接访问我的 ArrayList 字符串，即他们甚至可以在不调用我的 setter 的情况下修改它？
我觉得这极大地打破了封装的概念。除了动态创建一个具有相同值的新 ArrayList 并返回它之外，是否有正常的解决方法，或者我误解了什么？
编辑：我知道 Java 并不是真正的引用传递，而是传递原始对象地址的副本，但这与将对象暴露给类外的对象时传递引用的效果相同
我只是在学习 sizers 并且对如何实现这一点感到有些困惑。
如果我在一个框架中有一个水平框 sizer 并向其添加两个按钮（每个按钮的比例为“1”），那么它们都将拉伸以占据 sizer 的整个水平宽度（等于框架的整个水平宽度） ) 并均匀分布（参见下面的示例 1）。
示例 1 代码：
wxFrame* frame = new wxFrame(nullptr, wxID_ANY, "Frame");
wxPanel* panel = new wxPanel(frame, wxID_ANY);
wxBoxSizer* buttonSizer = new wxBoxSizer(wxHORIZONTAL);
wxButton* buttonOk = new wxButton(panel, wxID_OK, "Ok");
wxButton* buttonCancel = new wxButton(panel, wxID_CANCEL, "Cancel");
buttonSizer->Add(buttonOk, 1, wxALL, 10);
buttonSizer->Add(buttonCancel, 1, wxALL, 10);
panel->SetSizerAndFit(buttonSizer);
frame->Show();
但是，如果我希望这些按钮保持其原始大小（不被拉伸），但仍然均匀分布在框架中，并且仍然在每个 wxSizerItem 内水平居中怎么办？也就是说，水平 sizer 的两个“列”都占据了对话框的一半，并且每个按钮都在这些列中的每一列中居中？我将如何做到这一点？这是一张图。按钮应该是它们的默认大小。
______________________________________
| | Button 1 | | Button 3 | |
--------------------------------------
以下代码不起作用：
buttonSizer->Add(buttonOk, 0, wxALL, 10);
buttonSizer->Add(buttonCancel, 0, …编辑：这对我来说是“倒退”——我可能缺少一些直觉
给定一个 glm 变换函数，例如 glm::translate，这两个参数首先是一个矩阵m，然后是一个用于平移的向量v。
直观地说，我希望这个函数在我的矩阵变换“之后”应用翻译，即将一个对象乘以返回的矩阵将首先应用m然后是指定的翻译v。
这种直觉来自这样一个事实，即人们通常以数学顺序构建一个变换，例如首先计算一个比例矩阵，然后应用旋转，然后变换等。所以我认为函数调用顺序是相同的（即给定一个矩阵，我可以只需调用glm::translate即可应用在应用我的矩阵变换后发生的平移）
然而，正如在这个线程中提到的，情况并非如此——首先应用翻译，然后是传入的矩阵m。
我认为这与某些线程建议的列主要/行主要约定和符号没有任何关系。这有历史原因吗？这对我来说似乎有点倒退，除非有足够的理由，否则我可能会重写这些函数。
我见过使用 a 的代码const std::vector，但是不明白为什么简单地使用 anstd::array没有意义。
向量的值似乎在编译时初始化。
有什么好处const std::vector？
编辑：向量不大，只有几个字符串，但是我认为这可能是一个优势。
以下代码由于从未调用 std::string 的构造函数而中断，因为对 malloc 的调用似乎并未调用类成员的构造函数。
如何在不使用 new 的情况下调用 std::string 的构造函数？或者我是否必须在分配内存后在整个结构上使用新的位置？
#include <string>
class MyClass
{
std::string value;
};
int main()
{
MyClass* cls = (MyClass*)malloc(sizeof(MyClass));
cls->value = "hello";
system("pause");
}
编辑：
阅读评论后，我想知道以下代码是否会按预期工作？不确定是否需要调用除整个类的析构函数之外的任何析构函数。
#include <string>
class MyClass
{
std::string value;
};
int main()
{
MyClass* cls = (MyClass*)malloc(sizeof(MyClass));
cls = new(cls) MyClass;
cls->value = "hello";
cls->~MyClass();
free(cls);
system("pause");
}