isnullxbh's questions

编译 MySQL c-std=c++20时出现以下错误：error: expected unqualified-id before ')' token。

有问题的代码部分：

template<std::size_t N>
class Bitmap { ... };

template<>
class Bitmap<64>
{
public:
    Bitmap<64>() { ... };
    //........^
};

由于模板类的完全特化的声明与普通类的声明相同，因此还必须使用通常的语法来声明模板类的特化的成员函数：

template<>
class Bitmap<64>
{
public:
    Bitmap() { ... };
};

不幸的是，我在标准中找不到对上述内容的“直接”确认（或反驳），所以我请求您的帮助。

我试过用 GCC 和 Clang 编译这段代码。后者不会在 C++17 或 C++20 中引发错误。带有 C++17 的 GCC 也可以无错误地构建代码。有趣的是，将代码更改为：

template<>
class Bitmap
{
public:
    explicit Bitmap<64>() { ... };
};

导致 GCC 即使使用-std=c++20. 这看起来已经像是编译器中的一个错误。

编码：

template<typename T>
class Foo;

template<typename T>
constexpr auto operator==(const Foo<T>& lhs, const Foo<T>& rhs) -> bool;

template<typename T>
class Foo
{
public:
    friend constexpr auto operator==<T>(const Foo<T>&, const Foo<T>&) -> bool;
};

在这种情况下，我需要在朋友声明中指定 constexpr 吗？在标准中找到了这个：

当友元声明引用函数模板的特化时，函数参数声明不应包含默认参数，也不应在此类声明中使用 inline、constexpr 或 consteval 说明符。

但是，在同一个 cppreference 上，您可以找到带有的示例friend constexpr bool operator..，因此我不确定我是否正确理解了上述标准摘录。

例子：

订户：

class Subscriber {};

基类：

class SubscribableChannel
{
public:
    virtual ~SubscribableChannel() = default;

public:
    auto subscribe(Subscriber&) -> void;
    auto unsubscribe(Subscriber&) -> void;

private:
    virtual auto internal_subscribe(Subscriber&) -> void = 0;
    virtual auto internal_unsubscribe(Subscriber&) -> void = 0;
};

auto SubscribableChannel::subscribe(Subscriber& s) -> void
{ internal_subscribe(s); }

auto SubscribableChannel::unsubscribe(Subscriber& s) -> void
{ internal_unsubscribe(s); }

后代阶层SubscribableChannel：

class PubSubChannel : public SubscribableChannel
{
public:
    PubSubChannel() = default;

private:
    auto internal_subscribe(Subscriber&) -> void override {};
    auto internal_unsubscribe(Subscriber&) -> void override {};
    // Здесь появляется функция `unsubscribe`
    // имя которой совпадает с именем одной из функций базового класса,
    // но их сигнатуры отличаются: Subscriber& vs (Subscriber&, int)
    auto unsubscribe(Subscriber&, int) -> void {}
};

结果，尝试调用函数unsubscribe：

PubSubChannel channel;
Subscriber s;
channel.unsubscribe(s);

，导致以下错误：

错误：没有用于调用“PubSubChannel::unsubscribe(Subscriber&)”的匹配函数

注意：候选人：'void PubSubChannel::unsubscribe(Subscriber&, int)'

问题：这种行为可以接受吗？如果是，请提供C++ 标准中的段落编号链接。

环境：linux，clang-10/gcc-10

例子：

struct A {};
struct B { using A = A; };

int main()
{
    B b;
}

Clang 编译这个。GCC 抛出错误（示例）：

'using A = struct A' 的声明改变了 'A' 的含义

标准说：

如果一个类名 ([class.name]) 或枚举名 ([dcl.enum]) 和一个变量、数据成员、函数或枚举器在同一个声明区域（以任何顺序）以相同的名称（不包括通过 using 指令 ​​([basic.lookup.unqual])) 使声明可见，类或枚举名称在变量、数据成员、函数或枚举器名称可见的地方隐藏。

PS感谢来自莫斯科的弗拉德

在 S 类中使用的名称 N 应在其上下文中引用相同的声明，并且在 S 的完整范围内重新评估时。违反此规则不需要诊断

事实证明，GCC 的行为不正确？

例子：

template<typename T>
concept SequenceContainer = Container<T> && requires (T a)
{
    { a.front() } -> typename T::reference;
    /* requirements */
};

这里我们要求返回类型是非常量引用。但是如果a是 type const T，显然是正确的，增加一个额外的要求，说明“如果a是 type const T，那么成员函数调用front()必须返回const_reference”：

template<typename T>
concept SequenceContainer = Container<T> && requires (T a, const T b)
{
    { a.front() } -> typename T::reference;
    { b.front() } -> typename T::const_reference;
    /* requirements */
};

问题：有没有办法不指定第二个参数 - const T b，而是以某种方式说在这个要求中类型a应该被视为const T？我在en.cppreference.com或eel.is上都没有找到合适的东西。

也就是说，理想情况下，我想要类似的东西：

{ a.front() const } -> typename T::const_reference;

如果没有这样的方法，你需要按照上面的描述做（第二个参数为 const 类型）——如果可能的话，分享标准中相应段落的链接（我说的是草稿，当然） .

libclang 默认将 .h 文件视为包含 C 代码的文件。

例如，遍历以下类的 AST：

class Session
{
protected:
    const std::string m_username;
    unsigned          m_id;
};

给出结果：

cursor: Session, kind: VarDecl

如果将包含上述类定义的文件的扩展名更改为 hpp，libclang 开始正确解析 AST：

cursor: Session, of kind ClassDecl4
cursor: , of kind CXXAccessSpecifier39
cursor: m_username, of kind FieldDecl6
cursor: m_id, of kind FieldDecl6 

实际上，问题是：由于文件的路径完全传递给clang_parseTranslationUnit（见下面的代码），是否可以“强制”后者将 .h 文件视为包含 C++ 代码的文件？

要检查的代码：

#include <iostream>

#include <clang-c/Index.h>

std::ostream& operator<<(std::ostream& os, const CXString& str)
{
    os << clang_getCString(str);
    clang_disposeString(str);
    return os;
}

int main(int argc, char** argv)
{
    auto idx = clang_createIndex(0, 0);
    auto unit = clang_parseTranslationUnit(idx, argv[1], nullptr, 0, nullptr, 0, CXTranslationUnit_None);

    if (!unit)
        return -1;

    auto cursor = clang_getTranslationUnitCursor(unit);

    clang_visitChildren(cursor, [](CXCursor c, CXCursor, CXClientData)
        {
            std::cout << "cursor: " << clang_getCursorSpelling(c) << ", "
                      << "kind: " << clang_getCursorKindSpelling(clang_getCursorKind(c)) << std::endl;
            return CXChildVisit_Recurse;
        },
        nullptr);

    clang_disposeTranslationUnit(unit);
    clang_disposeIndex(idx);

    return 0;
}

资源：

Transaction tx = null;
try (final var session = HibernateSessionFactory.getInstance().openSession()) {
    tx = session.beginTransaction();
    session.save(c); // где с - экземпляр класса InternalDatabase
    tx.commit();
} catch (Exception ex) {
    logger.error("cannot save DB connection: {}", ex.getMessage());
    if (tx != null && (tx.getStatus() == TransactionStatus.ACTIVE || tx.getStatus() == TransactionStatus.MARKED_ROLLBACK)) {
        try {
            tx.rollback();
        } catch (Exception nex) {
            logger.error(nex.getMessage());
        }
    }
}

错误：

19:26:28.595 [JavaFX 应用程序线程] 错误 com.xxx.DatabaseConnectionsController - 无法保存数据库连接：类 org.hibernate.id.IdentifierGeneratorHelper$2 无法转换为类 java.lang.Long (org.hibernate.id.IdentifierGeneratorHelper$2在加载程序“app”的模块 org.hibernate.orm.core@6.0.0.Alpha2 中；java.lang.Long 在加载程序“bootstrap”的模块 java.base 中）

内部数据库：

@Entity
@Table(name = "internal_database")
public class InternalDatabase {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "id")
    private Long id;

    @Column(name = "name", nullable = false, unique = true)
    private String name;

    @Column(name = "conn_str", nullable = false)
    private String connectionString;

    @Column(name = "username")
    private String username;

    @Column(name = "password")
    private String password;

    @Column(name = "query")
    private String query;

    public InternalDatabase() { }
}

一开始，我手动创建了表格：

-- Entity: InternalDatabase
CREATE TABLE IF NOT EXISTS INTERNAL_DATABASE (
    ID          INTEGER GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
    NAME        VARCHAR(100)    NOT NULL,
    CONN_STR    VARCHAR(300)    NOT NULL,
    USERNAME    VARCHAR(100)    NOT NULL,
    PASSWORD    VARCHAR(100)    NOT NULL,
    QUERY       VARCHAR(500)    DEFAULT ''
);

ALTER TABLE "INTERNAL_DATABASE"
    ADD CONSTRAINT INTERNAL_DATABASE_NAME UNIQUE (NAME);

，然后hbm2ddl.auto在 Hibernate 配置文件中添加了一个选项 - 表是自动创建的，错误仍然存​​在。

hibernate.cfg.xml 看起来像这样：

<hibernate-configuration xmlns="http://www.hibernate.org/xsd/orm/cfg">
    <session-factory>
        <property name="connection.url">jdbc:h2:file:./xa;ifexists=true</property>
        <property name="connection.driver_class">org.h2.Driver</property>
        <property name="dialect">org.hibernate.dialect.H2Dialect</property>
        <property name="show_sql">true</property>
<!--        <property name="hbm2ddl.auto">create</property>-->

        <mapping class="com.xxx.entity.Permission"/>
        <mapping class="com.xxx.entity.Role"/>
        <mapping class="com.xxx.entity.User"/>
        <mapping class="com.xxx.entity.InternalDatabase"/>
    </session-factory>
</hibernate-configuration>

环境：macOS 10.13、10.14；JVM12；休眠 6.0.0Alpha2；H2

MWE：https ://github.com/isnullxbh/hhh-13630

是否有将 F# 编译为独立二进制文件而不是包含构建库的编译器？

这里 -/usr/local/share/dotnet/sdk/2.2.102/FSharp有 fsc 和 fsi - 但它们不是可执行文件。

环境：macOS、.NET Core 2.2

初始示例：

#include <ostream>

template<typename T>
void serialize(std::ostream& stream, const T& value) {}

template<typename T>
class Field
{
public:
    void serialize(std::ostream& stream)
    {
        serialize(stream, m_value);
    }

protected:
    T m_value = {};
};

代码示例无法编译（gcc-9，std=c++2a）。但是，编译器输出表明该函数serialize(std::ostream&, const T&)不能从给定的上下文中调用。将方法的主体更改为serialize以下代码：

::serialize(stream, m_value);

一切正常。但是，对我来说，为什么会出现这样的问题并不明显——具有不同签名的函数会突然产生冲突。给出标准特定段落的链接。

PS我检查了一个非模板类 - 情况类似。

如何从iex中的文件加载模块？类似于:load in GHCi。

也许我没有仔细阅读标准，但我从未找到单独的部分来描述允许的地址系列和协议。标头的描述netinet/in.h说标头必须包含以下常量，这些常量在getsockopt/setsockopt函数中用作级别（！）值：

1. IPPROTO_IP
2. IPPROTO_IPv6
3. IPPROTO_ICMP
4. IPPROTO_RAW
5. IPPROTO_TCP
6. IPPROTO_UDP

我可以这样解释吗？例如，符合 Posix 的系统不需要使用 SCTP 协议？

地址族的情况与此类似。

服务器代码：

#define EXAMPLE_PORT 6000
#define EXAMPLE_GROUP "239.0.0.1"

int main(int argc, char **argv) {

    struct sockaddr_in addr;
    int sock;
    ssize_t cnt;
    struct ip_mreq mreq;
    char message[50];
    socklen_t addrlen;

    /* set up socket */
    sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        perror("socket");
        return(1);
    }
    memset((char *)&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    addr.sin_port = htons(EXAMPLE_PORT);
    addrlen = sizeof(addr);

    /* send */
    addr.sin_addr.s_addr = inet_addr(EXAMPLE_GROUP);
    while (1) {
        time_t t = time(0);
        sprintf(message, "time is %-24.24s", ctime(&t));
        printf("sending: %s\n", message);
        cnt = sendto(sock, message, sizeof(message), 0,
                     (struct sockaddr *) &addr, addrlen);
        if (cnt < 0) {
            perror("sendto");
            return (1);
        }
        sleep(5);
    }

    return 0;
}

客户端代码：

#define EXAMPLE_PORT 6000
#define EXAMPLE_GROUP "239.0.0.1"

int main(int argc, char **argv) {

    if (argc < 2)
        return 1;

    const char *ip_addr = argv[1];

    struct sockaddr_in addr;
    int sock;
    socklen_t addrlen;
    ssize_t cnt;
    struct ip_mreq mreq;
    char message[50];

    /* set up socket */
    sock = socket(AF_INET, SOCK_DGRAM, 0);
    if (sock < 0) {
        perror("socket");
        return(1);
    }
    memset((char *)&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr(ip_addr); // *
    addr.sin_port = htons(EXAMPLE_PORT);
    addrlen = sizeof(addr);

    /* receive */
    if (bind(sock, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
        perror("bind");
        return (1);
    }
    mreq.imr_multiaddr.s_addr = inet_addr(EXAMPLE_GROUP);
    mreq.imr_interface.s_addr = htonl(INADDR_ANY);
    if (setsockopt(sock, IPPROTO_IP, IP_ADD_MEMBERSHIP,
                   &mreq, sizeof(mreq)) < 0) {
        perror("setsockopt mreq");
        return (1);
    }
    while (1) {
        cnt = recvfrom(sock, message, sizeof(message), 0,
                       (struct sockaddr *) &addr, &addrlen);
        if (cnt < 0) {
            perror("recvfrom");
            return (1);
        } else if (cnt == 0) {
            break;
        }
        printf("%s: message = \"%s\"\n", inet_ntoa(addr.sin_addr), message);
    }

    return 0;
}

问：我可以在同一台机器上运行多个客户端吗？现在我不能这样做，因为第二个客户端的启动以错误结束address already in use。

(*) 之前想用特定接口的IP地址绑定socket，是这样的：

addr.sin_addr.s_addr = htonl(INADDR_ANY);

有一个模板类：

template <typename T>
class CSerializer {
public:
    void write(std::ostream &stream, const T &value) const;
    void  read(std::istream &stream, T &value) const;
};

假定仅对 PDT 类型（int、unsigned、char 等）执行此类对象的实例化。

对于其他类型，假设存在此类的特化，例如，对于 type std::string：

template <>
class CSerializer<std::string> {
public:
    void write(std::ostream &stream, const std::string &str) const;
    void  read(std::istream &stream, std::string &str) const;
};

更远。我们有一个界面ISerializable：

class ISerializable {
public:
    virtual ~ISerializable() = default;

public:
    virtual void    write_binary(std::ostream &stream) const = 0;
    virtual void     read_binary(std::istream &stream) = 0;

    virtual size    serialized_size() const noexcept = 0;
};

，以及从它继承的许多类。我想专门CSerializer为 type设置一个类ISerializable，例如：

template <>
class CSerializer<ISerializable> {
public:
    void write(std::ostream &stream, const ISerializable &obj) const;
    void  read(std::istream &stream, ISerializable &obj) const;
};

它没有用 :) 为什么它没有用 - 我明白了。问题：是否可以编写这样的类特CSerializer化，当 T 是后代类时实例化ISerializable？

我知道如何通过 f-th 做到这一点，例如：

template <typename T, typename Enable = void>
CSerializer<T>* make_serializer() { ... }

template <typename T, typename std::enable_if<std::is_base_of< ... >>::value>
CSerializer<ISerializable>* make_serializer() { ... }

但让它成为一个“后备”选项。

UPD：他们建议在 C ++ 20 中，概念是理想的。创建了另一个问题。

环境：macOS，编写驱动程序，编译器 - clang

我正在尝试使用 f-th write，我连接了标头unistd.h- 编译器给出了错误 - 找不到文件。我在项目设置中指定了一个额外的路径来查找头文件 - /usr/include - 编译器会生成无数内容非常不同的错误。它与什么有关？我不能使用内核空间write？还是我应该使用其他一些功能？

环境：c11，gcc

资源：

#include <sys/types.h>      // system types
#include <sys/stat.h>       // FIFO
#include <fcntl.h>          // O_NONBLOCK
#include <errno.h>          // errno
#include <stdio.h>          // IO
#include <string.h>         // strerror
#include <unistd.h>         // unlink

#define rc_succ (0)
#define rc_fail (-1)
#define no_msg ("")
#define no_flags (0)

#define FULL_RDWR (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)

const char* fifo_pathname = "/tmp/vbi_flow";
int         fifo_creat_flags = O_NONBLOCK | FULL_RDWR;

int mkfifo_error_resolver(int err);

int main(int argc, char** argv) {
    int        rc;
    const int  buf_size = 1024;
    char       buf[buf_size];

    memset((void*)buf, 0x00, buf_size * sizeof(*buf));

create_fifo:
    // int dummy = 0; // раскомментируйте строку и получите ошибку 
                      // компиляции
    // create FIFO
    if (0 != (rc = mkfifo(fifo_pathname, (mode_t)fifo_creat_flags))) {
        if (rc_succ == mkfifo_error_resolver(errno)) goto create_fifo;
        perror("fifo create");
        return rc_fail;
    }

    printf("FIFO created. Related file: %s\n", fifo_pathname);

    int fifo_fd;
    if (-1 == (fifo_fd = open(fifo_pathname, O_RDWR))) {
        perror("open fifo file");
        goto cancel;
    }

    printf("File %s is open.\n", fifo_pathname);

    int should_cancel = 0;
    while (!should_cancel) {
        //
    }

cancel:
    // close file if exist
    if (fifo_fd > 0) {
        if (0 != (rc = close(fifo_fd)))
            perror("close fifo file");
    }

    // remove file related to FIFO
    if (0 != (rc = unlink(fifo_pathname))) {
        perror("fifo remove");
        return rc_fail;
    }

    printf("FIFO removed.\n");

    return 0;
}

int mkfifo_error_resolver(int err) {
    switch (err) {
        case EEXIST:
            return unlink(fifo_pathname); // unlink returns 0 if success

        default:
            return rc_fail;
    }
}

如果你在标签的正下方声明一个变量，这会导致编译错误：

但是请注意，在标签之后create_fifo，您可以找到声明变量的代码行fifo_fd。它不会导致编译错误。

即使在create_file我们 insert之后printf(...)，才声明一个变量，这仍然会导致编译错误。

有没有办法让编译器（g ++）在使用类似的函数时对未处理的异常（可能是某种标志）发誓

void f() throw (std::logic_error) {...} ?

Upd.：不相关，因为此构造被标记为已弃用

感谢@ixSci 的评论

UPD。 https://habr.com/post/430690/

手册说，从存储库（OS - ubuntu 18.04）安装堆栈后，您需要运行以下命令：

stack upgrade --binary 

升级完成后，stack 报告它的新版本在~/.local/bin。我现在有两个版本，一个在上面的路径中，另一个在/usr/bin。

例子：

#include <utility>       // std::pair
#include "vertex.hpp"    // IVertex class 

template <typename Key>
class IEdge {
public:
    using   VertexPtr = IVertex<Key>*;
    using Endvertices = std::pair<VertexPtr, VertexPtr>;
// ...
public:
    Endvertices& endvertices() noexcept = 0;    
};

template <typename Key = int>
class Edge : public IEdge<Key> {
public:
    // interface: IEdge
    Endvertices& endvertices() noexcept override;
};

编译器会生成大量与缺少关键字相关的错误typename，添加后者也无济于事。

问：怎么处理？我是否应该在每个别名前面加上带有当前模板参数的基类，例如：

typename IEdge<Key>::Envertices 

如果是这样，请解释为什么在使用模板的情况下这是必要的。

告诉我，是否可以在 Raspberry Pi 上激活 Macrovision 保护？

在这种情况下是否可以在 JS 中使用切片：

substr = str[index:]

如何在 Python 中做到这一点。或者，如果有其他更方便的类似物substr()- 请告诉我。