考虑:
struct str {};
str operator"" _X(long double d) {
return str();
}
用g ++ 4.7.2 Wall std = c ++ 11编译好
但现在如果我给双倍:
str operator"" _X(double d) {
return str();
}
我收到以下错误消息:main.cpp | 3 | error:'str operator""_ X(double)'具有无效的参数列表
问题是什么 ？这与"不可能重新定义内置文字后缀的含义"(Stroustrup FAQ)有关吗？你能想到一个解决方法吗？
我有以下代码
class A {
public:
A(){}
~A(){}
private:
std::vector<std::unique_ptr<double> > x;
};
A f() {
A a;
return a;
}
int main() {
A a=f();
return 0;
}
除非我注释掉析构函数,否则它不会编译(gcc 4.7).实际上,我在代码中并不需要这个析构函数,我只是想将它用于调试目的.
但是,我不明白发生了什么,因此我担心我做错了什么.这里发生了什么？
假设我有以下代码:
class B { /* */ };
class A {
vector<B*> vb;
public:
void add(B* b) { vb.push_back(b); }
};
int main() {
A a;
B* b(new B());
a.add(b);
}
假设在这种情况下,B*可以处理所有原始指针unique_ptr<B>.
令人惊讶的是,我无法找到如何使用转换此代码unique_ptr.经过几次尝试,我想出了以下代码,它编译:
class A {
vector<unique_ptr<B>> vb;
public:
void add(unique_ptr<B> b) { vb.push_back(move(b)); }
};
int main() {
A a;
unique_ptr<B> b(new B());
a.add(move(b));
}
所以我的简单问题是:这是实现它的方式,特别是,这是move(b)唯一的方法吗？(我在想rvalue引用,但我不完全理解它们.)
如果你有一个完整的移动语义解释链接unique_ptr,我无法找到,请不要犹豫,分享它.
编辑根据http://thbecker.net/articles/rvalue_references/section_01.html,我的代码似乎没问题.
实际上,std :: move只是语法糖.对于类X的对象x,move(x)与以下内容相同:
static_cast <X&&>(x)
需要这两个移动函数,因为转换为右值引用:
新的基于范围的for循环确实提高了可读性,并且非常易于使用.但是,请考虑以下事项:
map<Foo,Bar> FooAndAssociatedBars;
for (auto& FooAndAssociatedBar : FooAndAssociatedBars) {
FooAndAssociatedBar.first.doSth();
FooAndAssociatedBar.second.doSomeOtherThing();
}
它可能是一个细节,但我发现如果我能做到这样的话会更具可读性:
for ( (auto& foo, auto& bar) : FooAndAssociatedBars) {
foo.doSth();
bar.doSomeOtherThing();
}
你知道一个等价的语法吗？
编辑: 好消息:C++ 17有一个解决这个问题的提议,称为结构化绑定(见1).在C++ 17中,您应该能够编写:
tuple<T1,T2,T3> f(/*...*/) {
/*...*/
return {a,b,c};
}
auto [x,y,z] = f(); // x has type T1, y has type T2, z has type T3
这解决了这个可读性问题
我目前正在开发Code :: Blocks的中/大项目,我想知道如何组织我的文件.
首先,似乎在Code :: Blocks中创建"虚拟文件夹"非常自然,但是在磁盘上,所有文件都在项目的根文件夹中,对我来说似乎很麻烦:如果我想在代码之外做一些事情: :块,文件很难找到.我应该使用这种方法吗？
然后,如果我每次需要它时都创建"真实"文件夹,我需要将它们添加到路径中以便构建它们.另外,Code :: Blocks似乎不喜欢这样.有没有一种简单的方法可以对Code :: Blocks"构建项目,好像我的项目目录中的子文件夹中的文件直接位于根项目目录中"？
我没有在互联网上找到项目通常如何组织Code :: Blocks,欢迎任何链接
注意:这个问题非常接近于类内朋友函数的返回类型推导,但我没有在那里找到我的问题的答案.
用clang 3.4测试std = c ++ 1y和clang 3.5用std = c ++ 14和std = c ++ 1z
此代码编译:
#include <iostream>
template<class T>
class MyClass {
public:
MyClass(T const& a) : impl(a) {}
template<class T0, class T1> friend auto
// requires operator+(T0,T1) exists
operator+(MyClass<T0> const& a, MyClass<T1> const& b)
{
return MyClass<decltype(a.impl+b.impl)>{a.impl + b.impl};
}
T getImpl() const { return impl; }
private:
T impl;
};
int main() {
MyClass<int> x(2);
MyClass<long> y(2);
auto z = x+y;
std::cout << z.getImpl() …假设我有一个generate_my_range对 a range（特别是 is regular）建模的类。那么下面的代码是否正确：
auto generate_my_range(int some_param) {
auto my_transform_op = [](const auto& x){ return do_sth(x); };
return my_custom_rng_gen(some_param) | ranges::views::transform(my_transform_op);
}
auto cells = generate_my_range(10) | ranges::to<std::vector>;
是my_custom_rng_gen(some_param)采取按值（第一）管道运营商，还是我有一个参考晃来晃去，一旦我离开generate_my_range scope ?
函数调用会一样ranges::views::transform(my_custom_rng_gen(some_param),my_transform_op)吗？
如果我使用左值引用是否正确？例如：
auto generate_my_range(int some_param) {
auto my_transform_op = [](const auto& x){ return do_sth(x); };
auto tmp_ref = my_custom_rng_gen(some_param);
return tmp_ref | ranges::views::transform(my_transform_op);
}
如果这些操作的值采用范围，那么如果我将左值引用传递给容器，我该怎么办？我应该使用ranges::views::all(my_container)模式吗？
我是C++ 11的一些代码.我有
class X { /* */ };
class A {
std::vector<X*> va_x;
};
class B {
std::vector<X*> vb_x;
std::vector<A> vb_a;
};
我的类A中的"va_x"的X*s指向我的类B中"vb_x"的X*s指向的对象.
现在我想使用智能指针.对我来说,似乎很清楚,B类拥有X*指向的对象的所有权(特别是因为我的A实例属于B)
所以我应该在B中使用unique_ptr for X:
class B {
std::vector<unique_ptr<X>> vb_x;
std::vector<A> vb_a;
};
我的问题是,我应该为A班做些什么？我应该保留原始指针吗？通过这样做,在我的单元测试中,我必须承认它导致尴尬的事情(imo),例如(不要担心封装,这不是重点):
unique_ptr<X> x(new X());
A a;
a.va_x.push_back(&(*x)); //awkward, but what else can I do?
A.vb_a.push_back(a); //ok
B.vb_x.push_back(move(x)); //ok
我想知道std::visit返回类型转换应该如何工作.
上下文如下:我有一个变体对象,我想std::visit根据它的底层类型应用(通过)不同的函数.每个函数的结果可能有不同的类型,但我希望std :: visit将其打包为变体类型.
伪代码:
我有:
variant<A,B> obj
f(A) -> A
f(B) -> B
我想要:
if obj is of type A => apply f(A) => resA of type A => pack it in variant<A,B>
if obj is of type B => apply f(B) => resB of type B => pack it in variant<A,B>
现在,根据cppreference,std :: visit的返回类型是"所选访问者调用返回的值,转换为所有可能的std :: invoke表达式的公共类型"但是没有指定常见类型的含义.是std::common_type吗？在这种情况下,它不适用于gcc 7.2:
#include <variant>
#include <iostream>
#include <type_traits>
struct A {
int i;
};
struct …请考虑以下带有模板方法设计模式的代码:
class A {
public:
void templateMethod() {
doSomething();
}
private:
virtual void doSomething() {
std::cout << “42\n”;
}
};
class B : public A {
private:
void doSomething() override {
std::cout << “43\n”;
}
};
int main() {
// case 1
A a; // value semantics
a.templateMethod(); // knows at compile time that A::doSomething() must be called
// case 2
B b; // value semantics
b.templateMethod(); // knows at compile time that B::doSomething() must be called
// case 3 …c++ virtual-functions inline compiler-optimization template-method-pattern