来自网络的数据包在末尾添加了填充字节以进行对齐。我想跳过这些字节，但数据包大小可变但已知。给定一个 number n，如何将其四舍五入到下一个 4 字节对齐？
我正在尝试使用向量创建一个类数组,但我认为我在实例化数组时遇到了错误的语法.我得到的错误是:
error: request for member 'setX' in objects[0], which is of non-class type 'std::vector'
#include <iostream>
#include <vector>
using std::cout;
class A {
public:
void setX(int a) { x = a; }
int getX() { return x; }
private:
int x;
};
int main() {
std::vector<A> *objects[1];
objects[0].setX(5);
objects[1].setX(6);
cout << "object[0].getX() = " << objects[0].getX() << "\nobject[1].getX() = " << objects[1].getX() << std::endl;
}
这是一个非常简单的例子,我希望你们中的一些人能回答.这是一个应该返回参数中给出的最大值的函数.但问题是我不明白它是如何做到的.
function max(a, b) {
return [a, b][ +(a < b) ];
}
我已经习惯了看起来像这样的max函数,所以我不知道上面是如何工作的:
function max(a, b) {
return a > b ? a : b;
}
如果有人能够向我解释这段代码究竟是如何找到最大的数字,那将非常有帮助.例如,他为什么要使用数组？为什么一元+会以这种方式使用？(我是JS的新手).
为什么以下打印"Generic"而不是"const A&"？我猜测一个dynamic_cast<>人可以完成调用第一个的技巧,f但事实并非如此.为什么是这样？
struct A {}; struct B : A {};
template <const A &> void f() { std::cout << "const A &"; }
template <typename T> void f(T) { std::cout << "Generic"; }
int main() {
B b;
f(dynamic_cast<const A &>(b)); // "Generic"
}
我正在阅读文档,std::mutex::try_lock它有这个例子:
#include <iostream>
#include <mutex>
int main()
{
std::mutex test;
if (test.try_lock() == true)
std::cout << "lock acquired" << std::endl;
else
std::cout << "lock not acquired" << std::endl;
test.unlock(); // now unlock the mutex
test.lock(); // to lock it again
if (test.try_lock()) // true can be left out
std::cout << "lock acquired" << std::endl;
else
std::cout << "lock not acquired" << std::endl;
test.lock(); // and now the finale (a block)
}
在第二个if语句中,他说真的可以被排除在外.为什么这是第二个,而不是第一个.我检查过它说try_lock返回一个布尔值,那么它怎么能不是真或假,从而使== true检查变得多余？
我正在尝试重载[]运算符,以便我可以访问a的元素std::tuple.出于某种原因,我收到以下错误:
prog.cpp:11:73:错误:在函数体
prog.cpp 外使用参数'N' :11:73:错误:在函数体
prog.cpp 外使用参数'N' :11:73:错误:使用参数'N'在函数体外部
prog.cpp:11:89:错误:模板参数1无效
很奇怪,因为大多数都是第一次重复.而且我不明白为什么我得到那个错误,因为不是因为我们可以使用参数作为返回类型而不是返回类型的全部内容？
#include <tuple>
template <class... Args>
struct type_list
{
std::tuple<Args...> var;
type_list(Args&&... args) : var(std::forward<Args>(args)...) {}
auto operator[](std::size_t const N) -> typename std::tuple_element<N, std::tuple<Args...>>::type&&
{
return std::get<N>(var);
}
};
int main()
{
type_list<int, int, bool> array(2, 4, true);
}
如果有人能够解释为什么会发生这种情况以及如何让它发挥作用,那将非常感激.谢谢.
我有一个TU,其全局功能不会被任何其他TU使用.我读到它声明它们static给了它们内部的联系,从优化的角度来看这是好的.但我想知道我应该使用它们的正确情况.当我知道它们不会在程序中的任何其他地方使用时,我是否应该始终给出全局函数/变量内部链接？
我在某处读到单例是线程不安全的.我试图理解为什么会这样.如果我有一个像这样的单例对象:
class singleton final
{
public:
static singleton& instance()
{
static singleton unique;
return unique;
}
private:
singleton() = default;
singleton(singleton const&) = delete;
singleton& operator=(singleton const&) = delete;
};
如果我有这样的代码:
singleton *p1, *p2;
auto t1 = std::thread([] { p1 = &singleton::instance(); });
auto t2 = std::thread([] { p2 = &singleton::instance(); });
t1.join();
t2.join();
是否有可能p1和p2指向两个不同的singleton实例？如果unique是static,它的"静态"性质是否在完全初始化之前不会生效？如果是这样,这是否意味着可以同时访问静态对象的初始化,从而允许创建多个静态对象？
我认为这会奏效.
typedef auto var;
但我得到错误:
error: typedef declared 'auto'
相反,它适用于任何其他关键字:
typedef int num;
为什么我收到错误？
我正在尝试理解新的C++ 11功能; 更具体地说,引用限定符(其中一个)将赋值限制为rvalues.但由于某种原因,我无法使用此代码.当我将A对象分配给alvalue x(a = x)时,会出现错误.
prog.cpp:5:47:错误:在
'&'令牌
prog.cpp 之前的预期初始化程序:在函数中'int main()':
prog.cpp:15:9:错误:'operator='在'a = x'
prog.cpp中不匹配:3:10:注意:候选者是:A& A::operator=(const A&)
struct A {
template <typename T> auto operator = (T) & -> A & {
return *this;
}
};
int main() {
A a;
int x = 4;
a = x;
}
当我拿出引用限定符时,代码可以工作.我能做错什么？