小编pep*_*er0的帖子

是否可以在堆栈展开期间销毁的对象的析构函数中使用std :: current_exception？

有关cppreference的文档说:

如果在异常处理期间调用(通常在catch子句中),则捕获当前异常对象(...)

但是我不清楚堆栈展开是否是异常处理的一部分.

在stackoverflow的一些排名最高的答案中,作者认为这是可能的.

我对我的编译器进行了一些测试(g ++(Ubuntu 4.8.2-19ubuntu1)4.8.2),似乎在这种情况下std :: current_exception返回空指针.

#include <exception>
#include <stdexcept>
#include <iostream>


struct A
{
    ~A()
    {
        std::clog << "in destructor"<<std::endl;
        std::clog << "uncaught_exception: " << std::uncaught_exception() << std::endl;
        std::clog << "current_exception: " << (bool)std::current_exception() << std::endl;
    }
};

int main(int argc, char **)
{
    try
    {
        A aa;
        std::clog << "before throw"<<std::endl;
        if(argc>1)
            throw std::runtime_error("oh no");
    }
    catch(...)
    {
        std::clog << "in catch block"<<std::endl;
        std::clog << "uncaught_exception: " << std::uncaught_exception() …

我将从例子开始.在boost中有一个很好的"tokenizer"类.它需要将一个字符串标记为构造函数中的参数:

std::string string_to_tokenize("a bb ccc ddd 0");
boost::tokenizer<boost::char_separator<char> > my_tok(string_to_tokenize);
/* do something with my_tok */

字符串未在标记化器中修改,因此它由const对象引用传递.因此我可以在那里传递一个临时对象:

boost::tokenizer<boost::char_separator<char> > my_tok(std::string("a bb ccc ddd 0"));
/* do something with my_tok */

一切都很好,但如果我尝试使用标记器,就会发生灾难.经过简短的调查,我意识到,tokenizer类存储了我给它的引用,并在进一步使用时使用.当然,它不能很好地引用临时对象.

文档没有明确说明在构造函数中传递的对象将在以后使用,但是,也没有说明,它不会是:)所以我不能假设这个,我的错误.

但是有点混乱.一般情况下,当一个对象通过const引用获取另一个对象时,它表明可以在那里给出临时对象.你怎么看？这是一个糟糕的习俗吗？在这种情况下,是否应该使用指向对象(而不是引用)的指针？或者更进一步 - 对于允许/禁止给临时对象作为参数的参数有一些特殊的关键字是不是很有用？

编辑:文档(版本1.49)相当简约,唯一可能表明这样的问题的部分是:

注意:在构造时实际上没有进行解析.解析是按需完成的,因为令牌是通过begin提供的迭代器访问的.

但它没有明确说明,将使用给定的相同对象.

然而,这个问题的重点是在这种情况下讨论编码风格,这只是启发我的一个例子.

假设我们有一个模板函数"foo":

template<class T>
void foo(T arg)
{ ... }

我可以针对某些特定类型进行专业化,例如

template<>
void foo(int arg)
{ ... }

如果我想对所有内置数值类型(int,float,double等)使用相同的特化,我会多次写这些行.我知道身体可以被扔到另一个功能,并且只是在每个专业的身体中调用它,但是如果我能避免为每种类型写出这个"void foo(...")会更好.是否有有没有可能告诉编译器我想对所有这些类型使用这个特化？

我想知道我是否可以假设在相同的64位浮点数上的相同操作在任何现代PC和大多数常见编程语言中给出完全相同的结果？(C++,Java,C#等).我们可以假设,我们正在对数字进行操作,结果也是一个数字(没有NaN,INF等等).

我知道使用浮点数(IEEE 854-1987和IEEE 754-2008)有两种非常类似的计算标准.但是我不知道它在实践中是怎么回事.

我已经读过不建议对来自不同线程的套接字进行多次操作.但是,如果我从同一个线程socket.async_read和下一个socket.async_write调用(不等待前一个完成)怎么办？当其中一项操作完成后,我可以预见到正确的回调将会运行吗？

如果我们有一个带有非显式构造函数的不可移动的非可复制类,我们可以返回它并使用如下(在C++ 11中):

#include <iostream>
class NonCop
{
public:
    /*non explicit*/ NonCop(int a, int b) : number(a + b) {}
    NonCop(const NonCop&) = delete;
    int number;
};

NonCop get_non_cop()
{
    return {1, 2};
}

int main()
{
    NonCop &&nc = get_non_cop();
    std::cout << "three: " << nc.number << std::endl;
    return 0;
}

但是,如果构造函数是显式的,则它不起作用.有没有任何方法在C++ 11/C++ 14中执行此操作而不进行任何修改NonCop？

目前我正在使用从NonCop派生的解决方法,使用"deexplicits"构造函数的包装器,但它看起来并不漂亮.

我正在尝试在谷歌协议缓冲区中定义我的自定义字段选项。如果我创建这样的文件，一切正常：

import "google/protobuf/descriptor.proto";

package tutorial;

extend google.protobuf.FieldOptions {
  optional int32 myopt = 70000;
}

message Persona {
  required string name = 1 [(myopt)=5];
}

但是，如果我尝试将“myopt”定义移动到另一个文件，编译将失败：

myext.proto：

package myext;

import "google/protobuf/descriptor.proto";

extend google.protobuf.FieldOptions {
  optional int32 myopt = 70000;
}

地址簿.proto：

import "google/protobuf/descriptor.proto";
import "myext.proto";

package tutorial;


message Persona {
  required string name = 1 [(myopt)=5];
}

汇编：

$ protoc --cpp_out=. -I/usr/include -I. addressbook.proto
addressbook.proto:8:29: Option "(myopt)" unknown.

有没有什么方法可以在其他文件中定义自定义字段选项而不是使用它的文件？如果我想在多个 .proto 文件中使用我的选项，将公共部分移动到公共文件非常重要。

请考虑以下代码:

struct Foo : std::enable_shared_from_this<Foo>
{

};

struct Bar
{
    Foo foo;
};

int main()
{
    std::shared_ptr<Bar> bar_p(new Bar);

    //make shared_ptr to member with aliasing constructor
    std::shared_ptr<Foo> foo_p(bar_p, &bar_p->foo);
    assert(bar_p->foo.shared_from_this()); //fail! throws bad_weak_ptr
}

不幸的是,它没有按预期工作(至少在GCC 4.8.2中).我查看了代码,似乎别名构造函数根本不调用__enable_shared_from_this_helper()哪个是正确工作所必需的shared_from_this().

有没有人知道它为什么以这种方式设计？将shared_ptr从shared_from_this返回给成员有什么问题吗？

我有一个静态库、一个动态库（使用静态库）和一个可执行文件（使用两者）：

$ cat static.cpp
int use_static()
{
    return {};
}

void unused_in_static() {}

$ cat shared.cpp
void use_static();

void use_shared()
{
    use_static();
}

void unused_in_shared() {}

$ cat app.cpp
void use_shared();
void use_static();

int main()
{
    use_shared();
    use_static();
}

然后我构建它们：

#!/bin/bash -xe
COMPILE_OPTIONS="-ffunction-sections -fPIC"

g++ $COMPILE_OPTIONS -c -o static.o static.cpp
ar qc libstatic.a static.o

g++ $COMPILE_OPTIONS -c -o shared.o shared.cpp
g++ -Wl,-gc-sections -shared -o libshared.so shared.o libstatic.a

g++ $COMPILE_OPTIONS -c -o app.o app.cpp
g++ -Wl,-gc-sections -Wl,-rpath=. -o app app.o libstatic.a …

我们可以使用typeof运算符获取gcc中函数返回的类型,如下所示:

typeof(container.begin()) i;

是否有可能做一些类似的功能采取一些参数,但不给它们？例如,当我们有功能:

MyType foo(int, char, bool, int);

我想检索这个"MyType"(可能使用typeof运算符),假设我只知道函数的名称("foo"),并且不知道它所采用的参数.可能吗？

我正在使用为sam7s处理器编译的gcc 4.6.3.

我需要使用一些内联汇编:

int res;
asm volatile (" \
        MRS r0,CPSR     \n  \
        MOV %0, r0      \n  \
        BIC r0,r0,%1    \n  \
        MSR CPSR,r0     \n  \
        " : "=r" (res) : "r" (0xc0) : "r0" );
return res;

由gcc翻译为(由我添加的评论):

mov r3, #192    ; load 0xc0 to r3
str r0, [sl, #56]   ; preserve value of r0?

mrs r0, CPSR    ; load CPSR to r0
mov r3, r0      ; save r0 to "res"; r3 overwritten!
bic r0, r0, r3  ; 
msr …

很抱歉问这么简单的问题,但我找不到答案.Google没有说"C++ negation integral_constant"和类似的查询.

有没有在C++ 11,使任何特质std::true_type的std::false_type,反之亦然？换句话说,我想要更多的readeble版本

std::is_same<my_static_bool, std::false_type>

我当然知道我可以自己写,但如果有的话,我想用现有的.

我有这样的字符串:

some text that i'd like to ignore 123 the rest of line

格式是固定的,只有数字更改.我想阅读这个"123"并忽略其余部分,但要验证其余部分是否采用假定的格式.如果我使用scanf,我可以写:

int result = scanf("some text that i'd like to ignore %d the rest of line", &number);
assert(result==1);

然后通过检查结果我会知道该行是否格式正确.我正在寻找一些std ::或boost ::方法,例如使用这样的修饰符:

std::cin >> std::check_input("some text that i'd like to ignore") >> number >> std::ws >> std::check_input("the rest of line");
assert(!std::cin.fail());

当然我可以自己编写,但我不能相信没有简单的方法只使用std或boost来做到这一点.

在那儿？

编辑:在这种情况下,正则表达式对我来说太过分了.