小编zen*_*hoy的帖子

我试图打开一个二进制输出文件,我需要附加一些数据.我不能按顺序输出数据,所以我需要能够在文件流中搜索并且不能使用该std::ios::app标志.

不幸的是,当打开没有std::ios::app标志的输出文件流时,文件在打开时会被截断.这是一些示例代码:

#include <iostream>
#include <fstream>

int main() {
    std::ofstream file("output.bin", std::ios::binary | std::ios::ate);

    std::streamoff orig_offset = file.tellp();
    std::cout << "Offset after opening: " << orig_offset << std::endl;

    file.seekp(0, std::ios::end);
    std::streamoff end_offset = file.tellp();
    std::cout << "Offset at end: " << end_offset << std::endl;

    file << "Hello World" << std::endl;

    std::streamoff final_offset = file.tellp();
    std::cout << "Offset after writing: " << final_offset << std::endl;

    return 0;
}

我希望每次执行都将"Hello World"附加到文件中.但是,文件一打开就会被截断.

我究竟做错了什么？如果这是Visual Studio中的错误,是否有任何变通方法？

编辑:每次程序运行时,无论文件是否存在或已有内容,程序都会输出:

Offset after opening: 0 …

我有一个函数traits结构,它使用std::tuple_element以下方法提供函数参数的类型:

#include <iostream>
#include <tuple>
#include <typeinfo>

template <typename T>
struct function_traits;

template <typename T_Ret, typename ...T_Args>
struct function_traits<T_Ret(T_Args...)> {
    // Number of arguments.
    enum { arity = sizeof...(T_Args) };
    // Argument types.
    template <size_t i>
    struct args {
        using type
            = typename std::tuple_element<i, std::tuple<T_Args...>>::type;
    };
};

int main() {
    using Arg0 = function_traits<int(float)>::args<0>::type;
    //using Arg1 = function_traits<int(float)>::args<1>::type; // Error, should be void.

    std::cout << typeid(Arg0).name() << std::endl;
    //std::cout << typeid(Arg1).name() << std::endl;
}

工作示例:Ideone

如果索引i超出范围( …

当在Notepad ++中输入以创建新行时,是否可以获得新行的前一行的确切缩进？无论我尝试过什么,Notepad ++总是会用标签替换尽可能多的空格.

举个例子,假设我有以下内容(--->是一个标签,.是一个空格,|是光标):

--->--->a_very_long_variable_name = another_long_name
--->--->..........................+ yet_another_variable|;

假设我想在新行上添加第三个操作数.按Enter后,我希望如下:

--->--->a_very_long_variable_name = another_long_name
--->--->..........................+ yet_another_variable
--->--->..........................|;

不幸的是,Notepad ++实际产生的是:

--->--->a_very_long_variable_name = another_long_name
--->--->..........................+ yet_another_variable
--->--->--->--->--->--->--->--->..|;

有没有人知道可以用来获得缩进的精确副本的设置或插件,而不是用制表符替换空格？

如果块缩进/未入侵只会影响前导标签的数量,而不是再次将空格更改为制表符,那也不错.

TLDR:见最后一段.

我有operator&几个模板类的定义,如下所示:

template <typename T>
struct Class {
    Class(T const &t) { }
};

template <typename T_Lhs, typename T_Rhs>
struct ClassAnd {
    ClassAnd(T_Lhs const &lhs, T_Rhs const &rhs) { }
};

template <typename T, typename T_Rhs>
ClassAnd<Class<T>, T_Rhs> operator&(Class<T> const &lhs, T_Rhs const &rhs) {
    return ClassAnd<Class<T>, T_Rhs>(lhs, rhs);
}

template <typename T0, typename T1, typename T_Rhs>
ClassAnd<ClassAnd<T0, T1>, T_Rhs> operator&(ClassAnd<T0, T1> const &lhs, T_Rhs const &rhs) {
    return ClassAnd<ClassAnd<T0, T1>, T_Rhs>(lhs, rhs);
}

int main() {
    Class<int> …

缩短 a 时std::string，基本上有两种可能性：string.resize(length)或string.erase(length)。

鉴于我们知道字符串会变小，那么两者之间有什么区别？

在过去使用SFINAE选择构造函数重载时,我通常使用以下内容:

template <typename T>
class Class {
public:
    template <typename U = T, typename std::enable_if<std::is_void<U>::value, int>::type=0>
    Class() {
        std::cout << "void" << std::endl;
    }

    template <typename U = T, typename std::enable_if<!std::is_void<U>::value, int>::type=0>
    Class() {
        std::cout << "not void" << std::endl;
    }
};

但是,我刚刚遇到了这个替代方案:

template <typename U = T, typename std::enable_if<std::is_void<U>::value>::type...>
Class() {
    std::cout << "void" << std::endl;
}

考虑到以下是非法的......

template <typename U = T, void...> // ERROR!
Class() { }

...上面使用省略号而不是非类型模板参数的替代方法如何工作？

完整代码:http://coliru.stacked-crooked.com/a/64a1aaf13ce6099b

我已经实现了一个类型擦除引用类,可以从对任何类型的l值引用构造.但是,对于是否允许从r值进行构造,我遇到了一个两难的困境.

我遇到过两个用例:

1. 将引用构造为局部变量

   int i = 42;
   Reference ref1 = i;   // This is allowed.
   Reference ref2 = 42;  // This should cause a compile error.
   

   Run Code Online (Sandbox Code Playgroud)

2. 将引用构造为函数参数

   void func(Reference ref);
   
   int i = 42;
   func(i);   // This is allowed.
   func(42);  // This should also be allowed.
   

   Run Code Online (Sandbox Code Playgroud)

实际上,我希望允许Reference从寿命大于引用的任何内容中隐式构造实例,但不允许从寿命较短的任何内容构建实例.

有没有办法实现这一点,即允许func(42)但不允许ref = 42？我可以自由地进行任何必要的更改Reference,但签名func应该保持不变.

我有一个部分或完全循环的图,我想根据前面节点的成本的加权和来计算每个节点的成本.没有传入边缘的节点具有分配给它们的固定成本.

例如,下面的图表标记了每个节点的计算成本(节点2的成本是固定的),每个边缘都标有前一个节点的权重.因此,节点1.33成本从1*0.33 + 0.5*2计算.

我目前使用迭代方法计算每个节点在某个epsilon内的成本,但我正在寻找一种能够精确计算成本的算法.上面的例子非常简单,实际问题涉及每个强连接组件约100个节点.对算法有什么建议可以解决这个问题吗？

我有一个从公共基类(Device)派生的大量(~100)个类.每个设备都可以接受类似大量命令的某个子集.不同的命令可以具有不同的数量和类型的参数,因此每个命令都由其自己的类型封装(如果需要可以更改).

有哪些模式允许我将命令传递给设备,只给出对Device基类的指针/引用,以便设备可以访问命令的类型和参数？

我想出的选项:

1. 最直接的方法是添加一个单独的虚方法,接受每个命令类型到基类Device.但是,这将导致基类中的大量虚拟方法仅在极少数派生类中被覆盖.
2. 我考虑了访问者模式,但由于命令类的数量大约等于设备类的数量,所以这并没有真正获得任何东西.
3. 使用RTTI(或每个命令唯一的枚举/标识符)来确定命令类型,然后切换/ if分支到适当的代码.这感觉非常脏,因为它绕过了正常的C++多态性.此外,dynamic_cast在这里非常不满意,所以这个选项几乎完全没有了.

对于一个模式的任何建议,如果在Device基类中没有大量的虚方法,就可以干净利落地使用它？

标题真的说明了一切:减一和蒂尔达(一补)零之间有什么区别？

在讨论指定所有位都设置的位掩码的最佳方法时出现了这个问题.以下哪项更好？

int func(int value, int mask = -1) {
    return (value & mask);
}

要么

int func(int value, int mask = ~0) {
    return (value & mask);
}

是否还有其他任何用途？

更新:在stackoverflow.com/q/809227/34509上有关于此主题的类似讨论,我在之前的研究中遗漏了这个问题 .感谢Johannes Schaub指出它.