小编Kol*_*nya的帖子

我正在阅读一些关于线程的手册,我想到他们展示的代码并不安全:

std::cout << "starting first helper...\n";
std::thread helper1(foo);

std::cout << "starting second helper...\n";
std::thread helper2(bar);

std::cout << "waiting for helpers to finish..." << std::endl;
helper1.join();   // #1 NOT SAFE
helper2.join();   // #2 NOT SAFE

我相信这段代码并不是绝对安全的.如果我没有误会,当控制到达标记为和的行时,无法保证helper1并且helper2已经处于可连接状态.线程仍然无法启动,此时没有任何ID.这将导致未被捕获的异常被抛出#1#2std::thread::join()

我认为以下代码解决了这个问题.我对吗？

std::cout << "starting first helper...\n";
std::thread helper1(foo);

std::cout << "starting second helper...\n";
std::thread helper2(bar);

std::cout << "waiting for helpers to finish..." << std::endl;
while ( helper1.joinable() == false ) { }
helper1.join();   // #1 SAFE …

我为我的项目制作了一个手工制作的互斥锁,但我怀疑它是否是线程安全的......

    bool blocked;

    while ( blocked )
    {

    }

    blocked = true;
    ...
    blocked = false;

可以说,线程A传递while循环并且没有及时阻塞标志(没有时间将标志设置为false),线程B也通过while循环!

1. 可能吗？为什么？

2. 正如我所知,互斥体具有完全相同的工作原理.为什么不能在互斥锁中发生这种情况？我读过有关这不能被中断的原子操作......所以check-if-mutex-available并mutex-block不能中断,对不对？

我有条件声明expensive_foo(),在99.9%的情况下是假的.我有一个条件陈述bar,在约50%的情况下都是如此.

如果两个陈述都是真的,我想要采取一些行动.所以我几乎肯定知道这expensive_foo()是假的,我想检查它是否bar属实.

下面的代码是否会检查expensive_foo()是否bar属实？或者expensive_foo()每次都会检查？

if ( bar && expensive_foo() )
{
    ...
}

或者我需要制作这样的结构:

if ( bar )
{
    if ( expensive_foo() )
    {
        ...
    }
}

我知道修改声明为常量的对象是一个UB.标题中提到的更复杂的例子怎么样？

class Foo
{
    public:
        Foo ( void ) { }
        int data;
};

int main ( void )
{
    const Foo foo;
    const_cast<Foo&>(foo).data = 0;   //  UB?
    return 0;
}

data被声明为非const,所以可以修改它.但是foo声明为const.所以我们似乎无法修改它.因此我相信在这里调用UB.我对吗？

更新:所以它实际上是一个UB.这意味着所有具有修改可变成员的伪常量成员的类在常量实例上产生UB.

class Foo
{
    public:
        mutable int data;
        Foo ( void ) { }
        void foo ( void ) const
        {
            some_modifications_of_data();
        }
};


const Foo foo;
foo.foo(); // UB?

这是否意味着如果你设计这种类,你必须明确提到在任何情况下都没有人可以在常量实例上调用这个方法？

recvfrom要求第5个参数是指向sockaddr结构的指针,第6个参数是指向a的指针socklen_t.

man recvfrom (3) 说:

如果地址的实际长度大于提供的sockaddr结构的长度,则应截断存储的地址.

我不知道如何检索具有AF_INET6地址族的发送套接字的地址,因为大小sockaddr_in6大于sockaddr它将被截断recvfrom.

我是否正确recvfrom无法检索大于sizeof(sockaddr)？的地址？

我是否正确,即使我定义了一个转换sockaddr_in6它的地址sockaddr*并将其传递给的实例recvfrom,该函数也无法知道有足够的空间来存储地址？

我定义了一组函数模板:

template < typename type >
void foo ( type object )
{
    //  foo the object
}

template < typename type >
void bar ( type object )
{
    //  bar the object
}

template < typename type >
void baz ( type object )
{
    //  baz the object
}

现在我想定义一个函数模板,它接受一个指向上面任何函数的指针.

    template < /* ??? */ , typename T , typename... TT >
    void for_each ( T parameter , TT... other parameters )
    {
       // process the first …

免责声明我不使用BOOST或其他图书馆

最后我了解了PointerToMemberFunction的工作原理.这是我的示例代码.

#include <iostream>

using namespace std;

class Foo
{
        public:
                void foo ( )
                {
                        cout << "I'm a foo method\n";
                };
};

class Bar
{
        public:
                void bar ( Foo* fooPtr , void(Foo::*fooFnPtr)() )
                {
                        (fooPtr->*fooFnPtr)();
                };
};

int main()
{
        Foo* foo = new Foo();
        Bar* bar = new Bar();

        bar->bar ( foo , &Foo::foo );

        return 0;
}

现在,问题是什么.Bar::bar必须以某种方式修改,因为在实际项目中它不会知道,什么类fooFnPtr是指针.换句话说,Bar::bar必须与任何班级合作,而不仅仅是Foo.我不会知道,指向传递给哪个类的实例的指针 …

试图编译代码:

class Foo
{
    public:
        Foo(Foo&){}
        Foo(int*){}
};

int main()
{
    int i = 2;
    Foo foo = &i;
    return 0;
}

得到这个:

prog.cpp: In function ‘int main()’:
prog.cpp:11:16: error: no matching function for call to ‘Foo::Foo(Foo)’
prog.cpp:11:16: note: candidates are:
prog.cpp:5:9: note: Foo::Foo(int*)
prog.cpp:5:9: note:   no known conversion for argument 1 from ‘Foo’ to ‘int*’
prog.cpp:4:9: note: Foo::Foo(Foo&)
prog.cpp:4:9: note:   no known conversion for argument 1 from ‘Foo’ to ‘Foo&’

我预计Foo foo = &i在线应该被称为Foo(int*)c-tor.

为什么编译器试图找到 …

我需要构造一个 SQL 查询，其中包含两个查询，UNION并限制返回的行数。

    $query = $queryOne
        ->union($queryTwo)
        ->limit($this->limit)
    ;

问题在于该LIMIT子句与第一个查询一起括在括号中。因此，第二个查询没有LIMIT子句。

我需要LIMIT为整个查询而不是子查询指定子句。

我正在尝试将 GitHub 工作流程与机密一起使用。我的设置是：

• 免费计划
• 私人组织
• 私人仓库
• 组织范围内的秘密

问题是，当我像这样使用它时，秘密的计算结果为空字符串：

echo ${{ secrets.CI_TOKEN }}

有趣的是，工作流代码本身似乎完全合法，因为***当我在存储库范围中覆盖它时，它开始评估秘密。

然后我注意到这个问题的可能原因。组织秘密用户界面有点矛盾。首先，它说我不能在免费计划中使用私人存储库的秘密，但然后我可以选择第三个选项并手动选择该私人存储库。

所以我想知道当您手动选择存储库时，免费计划是否实际上支持私人组织的私人存储库中的秘密？