主页 / user-3378179

Caduchon's questions

Martin Hope
Caduchon
Asked: 2024-03-20 18:46:45 +0800 CST
  • 11

请参阅以下代码，其中包含调用另一个抛出函数的函数的 3 个实现。

# include <stdexcept>

void f()
{
    throw std::runtime_error("");
}

void g1()
{
    f();
}

void g2() noexcept
{
    f();
}

void g3() noexcept
{
    try{ f(); } catch(...){ std::terminate(); }
}

int main()
{
    return 0;
}

根据我对规范的理解noexcept，g2和g3是严格等效的。但是，当我使用 GCC 在编译器资源管理器中编译它时，生成的代码对于g1and是严格等效的g2，但对于 则不是g3：

g1():
        push    rbp
        mov     rbp, rsp
        call    f()
        nop
        pop     rbp
        ret
g2():
        push    rbp
        mov     rbp, rsp
        call    f()
        nop
        pop     rbp
        ret
g3():
        push    rbp
        mov     rbp, rsp
        call    f()
        jmp     .L9
        mov     rdi, rax
        call    __cxa_begin_catch
        call    std::terminate()
.L9:
        pop     rbp
        ret

为什么 ？

c++
Martin Hope
Caduchon
Asked: 2024-02-22 22:27:23 +0800 CST
  • 5

我正在编写一个继承自std::unique_ptr具有克隆函数的类的类：

template <typename T>
class cl_ptr : public std::unique_ptr<T>
{
    public:
        cl_ptr() noexcept = default;
        cl_ptr(T* p) noexcept : std::unique_ptr<T>(p) {}
        cl_ptr(cl_ptr<T> const& cp) : std::unique_ptr<T>(cp ? cp->clone() : nullptr) {}
        cl_ptr(cl_ptr<T>&&) noexcept = default;
        cl_ptr<T>& operator=(cl_ptr<T> const& cp) { this->reset(cp ? cp->clone() : nullptr); return *this; }
        cl_ptr<T>& operator=(cl_ptr<T>&& cp) noexcept = default;
        ~cl_ptr() noexcept = default;
};

当我尝试从 type 的实例转换T为 type 的实例时出现错误T const：

cl_ptr<Foo> p1(new Foo);
cl_ptr<Foo const> p2 = p1; // <- Compiler error here
// error: conversion from ‘cl_ptr<Foo>’ to non-scalar type ‘cl_ptr<const Foo>’ requested

但我不知道如何实施。

当然我不希望这段代码编译：

cl_ptr<Foo const> p1(new Foo);
cl_ptr<Foo> p2 = p1; // <- Always wrong

最小可重现示例：

# include <memory>

template <typename T>
class cl_ptr : public std::unique_ptr<T>
{
    public:
        cl_ptr() noexcept = default;
        cl_ptr(T* p) noexcept : std::unique_ptr<T>(p) {}
        cl_ptr(cl_ptr<T> const& cp) : std::unique_ptr<T>(cp ? cp->clone() : nullptr) {}
        cl_ptr(cl_ptr<T>&&) noexcept = default;
        cl_ptr<T>& operator=(cl_ptr<T> const& cp) { this->reset(cp ? cp->clone() : nullptr); return *this; }
        cl_ptr<T>& operator=(cl_ptr<T>&& cp) noexcept = default;
        ~cl_ptr() noexcept = default;
};

class Foo
{
    public:
        Foo() = default;
        Foo(Foo const&) = default;
        ~Foo() noexcept = default;
        Foo* clone() const { return new Foo(*this); }
};

int main()
{
    cl_ptr<Foo> p1(new Foo);
    cl_ptr<Foo const> p2 = p1;
    cl_ptr<Foo> p3 = p2; // must fail

    return 0;
}
c++