我想在lambda中修改一个变量而不影响封闭范围.表现得像这样的东西:
std::vector vec = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
{
auto sum = 0;
std::for_each(vec.begin(), vec.end(), [sum](int value) mutable
{
sum += value;
std::cout << "Sum is up to: " << sum << '/n';
});
}
但是,我希望能够在不声明sumlambda之外的变量的情况下完成它.像这样的东西:
std::vector vec = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
std::for_each(vec.begin(), vec.end(), [auto sum = 0](int value) mutable
{
sum += value;
std::cout << "Sum is up to: " …我最近开始学习C++.我在std :: forward上有一个关于左值引用和右值引用的问题.根据我的理解,以下代码中的Func(mc)假设由于模板参数推导规则而调用Func(T&t).并且应该在函数内部使用消息"复制构造函数"调用MyClass的复制构造函数.但是,当我运行程序时,我无法得到它.我检查了带有右值引用的std :: forwad,并且复制构造函数在其他行中运行良好.请帮我理解代码中发生的事情.如果我容易犯错误或误解,我很抱歉花时间.非常感谢你.
class MyClass {
public:
MyClass() { printf("constructor.\n"); };
MyClass(MyClass&) { printf("copy constructor.\n"); };
MyClass(const MyClass&) { printf("const copy constructor.\n"); };
MyClass(MyClass&&) { printf("move constructor.\n"); };
int val = 3;
};
template <typename T>
void Func(T&& t) {
T new_t_(std::forward<T>(t));
new_t_.val *= 2;
};
main() {
MyClass mc;
Func(mc); // lvalue <- Func(T&)
Func(MyClass()); // rsvalue <- Func(T&&)
printf("mc.val=%d\n", mc.val); // this is for check
MyClass mc2(mc); // this is for check of copy constructor
} …我有一个traits类,它应该只提供一个关于其他类型的信息(以字符串的形式):
template<typename T>
struct some_traits {
static const char* const some_string;
};
我需要some_string为每种类型提供特殊实例.我知道如何执行此操作的常用方法是仅声明some_traits,然后编写特化:
template<typename T>
struct some_traits;
template<>
struct some_traits<blah> {
static const char* const some_string;
};
const char* const some_traits<blah>::some_string = "blah string";
然而,当我需要的只是一个专门的代码时,这是很多代码some_string.有没有办法简化这个？
我试图摆弄明确的特化,但未能提出一种语法,不会让编译器向我的脸部吐出有毒的错误信息.
笔记:
我正在尝试创建一个index_type_<N>类型,它将type根据索引的最大数量来返回索引的N位置N.
例如:
index_type_<32>::type index1; //uint8_t
index_type_<64000>::type index2; //uint16_t
index_type_<18446744073709551>::type index3; //uint64_t
我有以下代码拒绝编译,我无法确定原因,尽管在错误消息上搜索谷歌,它们似乎都没有与我的情况相关.
#include <iostream>
template<size_t N, typename T = void>
struct index_type_;
template<size_t N>
struct index_type_<N, typename std::enable_if<N <= 256, uint8_t>::value>
{
typedef uint8_t type;
};
template<size_t N, typename T = void>
struct index_type_;
template<size_t N>
struct index_type_<N, typename std::enable_if<N <= 65536, uint16_t>::value>
{
typedef uint16_t type;
};
template<size_t N>
struct index_type_<N, typename std::enable_if<N <= 4294967296, uint32_t>::value>
{
typedef uint32_t type;
}; …我一直在阅读GOTW102,并且想知道为什么make_unique比其他情况更安全,或者为什么f(new T(...))比例更安全f(new T1(...), new T2(...)).
make_unique博客的实施内容如下:
template<typename T, typename ...Args>
std::unique_ptr<T> make_unique( Args&& ...args )
{
return std::unique_ptr<T>( new T( std::forward<Args>(args)... ) );
}
现在我想知道是否f(new T(...))一般异常安全(无泄漏),或者如果它只是异常安全的情况下,make_unique因为增加的知识,建设者std::unique_ptr不扔？(T根据我的理解,如果新建的话会被泄露.
这是我想写的代码:
template <typename T1, typename ... tail>
class record : public record<tail...>
{
using baseT = record<tail...>;
T1 elem;
public:
record(T1 first, tail... rest)
: elem(first), baseT(rest...)
{}
template <int index>
inline constexpr T1& get()
{
// line 83:
return baseT::get<index-1>();
}
// line 85:
template <>
inline constexpr T1& get<0>()
{
return elem;
}
};
和我得到的编译器输出:( GCC 4.8.2 with -std=c++11)
record.hpp:85:15: error: explicit specialization in non-namespace scope 'class base::record<T1, tail>'
template <>
^
record.hpp:86:33: error: template-id 'get<0>' in …我有这个代码
#include <iostream>
size_t F()
{
return 0;
}
template <class Type, class... NextTypes>
size_t F(const Type& type, const NextTypes&... nextTypes)
{
if (!std::is_const<Type>::value)
return sizeof(type) + F(nextTypes...);
else
return F(nextTypes...);
}
int main()
{
int a = 0;
const int b = 0;
const size_t size = F(a,b);
std::cout << "size = " << size << std::endl;
return 0;
}
我试图在编译时知道常量参数和非常量参数的总大小.当前输出为8,由于某种原因,编译器认为b不是常量,我使用typeid并decltype打印类型a和b输出显示确实b是一个int而不是const int我预期的.我错过了什么？是否有可能将一组可变参数分别为const参数和非const？
在C ++ 14维基百科页面描述的新的语言功能，通过类型的寻址元组，与您可以做写：
tuple<string, string, int> t("foo", "bar", 7);
int i = get<int>(t); // i == 7
好吧，通常这会失败，即在通常情况下，一个元组具有多个相同类型的元素。这是一种非常特殊的（虽然我承认，这是很常见的）元组，但每个类型都有一个值。并且这种get隐含了-表示get<T>(t)形式的语义，好像不同类型中的值以某种方式相关。Tt
为什么拥有这样一种方法（在一般情况下不适用，并且似乎与某些情况相关）是一个好主意，我想您可以说出元组的子类吗？
为什么ISO/IEC 14882:2011标准(C++ 11)的PDF版本不同,价格从30美元到761美元不等？(见http://webstore.ansi.org或任何其他经销商)
顺便说一下:INCITS 30美元的版本刚刚发布了吗？它可以在ANSI网上商店购买,但不能在INCITS网上商店购买.
为什么模板类参数在参数之后具有默认值,但在variadic之前也必须具有默认值？ 实例
template<class A = int, class B, class ...Args> // B must have default argument
struct Dat{};
另一方面,如果A没有默认参数,那么ok:
template<class A, class B, class ...Args> // B must have default argument
struct Dat{};