全部问题(coding)

我觉得我需要什么

如何定义类型特征来检查某个类型的T函数是否::foo(T)已声明？

我发现很难::foo以 SFINAE 友好的方式实现。例如，如果编译器已经到了定义以下内容的地步，

template<typename T>
void f(T t) { foo(t); }

foo如果到现在还没有发现任何东西，那就太好了。

但是一旦我更改foo为::foo，就会出现硬错误。

用例（以防您认为我不需要上述内容）

我有一个这样的定制点：

// this is in Foo.hpp
namespace foos {
inline constexpr struct Foo {
    template <typename T, std::enable_if_t<AdlFooable<std::decay_t<T>>::value, int> = 0>
    constexpr bool operator()(T const& x) const {
        return foo(x);
    }
} foo{};
}

通过为所需类型foos::foo定义 ADL重载，可以定制调用的行为。foo

该特征的定义很简单：

// this is in Foo.hpp
template <typename T, typename = void>
struct AdlFooable : std::false_type {};

template <typename T>
struct AdlFooable<T, std::void_t<decltype(foo(std::declval<T const&>()))>>
    : std::true_type {};

鉴于

// this is in Bar.hpp
namespace bar {
    struct Bar {};
    bool foo(bar::Bar);
}

然后调用

// other includes
#include "Foo.hpp"
#include "Bar.hpp"
bool b = foos::foo(bar::Bar{});

工作正常，将foos::foo调用路由到bar::foo(bar::Bar)通过 ADL 找到的 。无论两个#includes 的顺序如何，这都能很好地工作，这很好，因为如果传递地包含它们，它们可以按任意顺序包含// other includes。

到目前为止，一切都很好。

我不太喜欢这种方法，因为人们可能会错误地定义下面的代码，而不是上面的第二个代码片段，

// this is in Bar.hpp
namespace bar {
    struct Bar {};
}
bool foo(bar::Bar);

在全球范围内foo。

在这种情况下，如果#include "Bar.hpp"恰好在之前出现#include "Foo.hpp"，则代码程序将会起作用，因为的主体Foo::operator()将::foo(bar::Bar)通过普通查找进行选择。

但是一旦#includes 的顺序被颠倒过来，代码就会被破坏。

是的，这个错误是foo(bar::Bar)在全局命名空间中进行定义的，但我认为这也是一个纯粹偶然不会被注意到的错误。

这就是为什么我想改变类型特征来表达“发现不合格的调用，但不是通过普通查找”foo(T)，或者更直接地说，“foo(std::declval<T>())必须编译，但不能::foo(std::declval<T>())编译”。

我正在处理一个相当统一的供应商提供的 API，并且希望以统一的方式检查和处理任何故障。为此，我编写了以下包装器：

template <typename Func, typename... Args>
auto awrap(Func &func, Args&&... args)
{
    auto code = func(args...);

    if (code >= 0)
        return code;

    ... handle the error ...
};
...
awrap(handlepath, handle, path, NULL, 0, coll, NULL);

上面的代码可以通过 clang 编译，但是 g++13 和 Microsoft VC++ 都对两个 NULL 参数提出抱怨：

... error: invalid conversion from 'int' to 'const char*' [-fpermissive]
   87 |                 auto code = func(args...

用 替换两个NULLs 可以nullptr解决问题，但是这有什么关系呢？

很可能，预处理器NULL会将 转换为0x0，甚至0在某个地方，但原始调用从未引起“注意”。在以下情况下，使用 NULL 非常合适：

handlepath(handle, path, NULL, 0, coll, NULL);

为什么在包装器中使用时会出现问题（对于某些编译器而言）？

更新：/usr/include/sys/_null.h我的 FreeBSD 系统上有以下代码：

#ifndef NULL

#if !defined(__cplusplus)
#define NULL    ((void *)0)
#else
#if __cplusplus >= 201103L
#define NULL    nullptr
#elif defined(__GNUG__) && defined(__GNUC__) && __GNUC__ >= 4
#define NULL    __null
#else
#if defined(__LP64__)
#define NULL    (0L)
#else
#define NULL    0
#endif  /* __LP64__ */
#endif  /* __GNUG__ */
#endif  /* !__cplusplus */

#endif

所以：

1. 对于 C，NULL是(void *)0；

2. 对于 clang++ 来说NULL和nullptr是同一件事，而对于 GNU 来说可能不是......

代码显示：

const fn = (length, label, callback) => {
  console.time(label);
  for (let i = 0; i < length; i++) {
    callback && callback(i);
  }
  console.timeEnd(label);
};

const length = 100000000;
fn(length, "1", () => {})  // very few intervals
fn(length, "2", () => {})  // regular
fn(length, "3", () => {})  // regular

然后我删除了第三个参数callback，它们的执行时间非常接近..

const fn = (length, label, callback) => {
  console.time(label);
  for (let i = 0; i < length; i++) {
    callback && callback(i);
  }
  console.timeEnd(label);
};

const length = 100000000;
fn(length, "1")  // regular
fn(length, "2")  // regular
fn(length, "3")  // regular

为什么？？？

这不是一个特定的错误，而是一个一般的 C++ 设计问题。考虑以下场景：

struct MyInterface {};

struct Data : MyInterface{};

struct DataWrapper
{
    SomeContainerOf<MyInterface*> getData()
    {...}
private:
    std::vector<Data> dataStorage;
};

根据我的要求，我需要访问器函数来DataWrapper返回值的容器MyInterface*（指针，因为我们真正返回Data值）。

理想情况下，我们希望在不复制的情况下完成此操作。我想知道做到这一点的最佳方法。据我所知，如下是惯用的 C++ 方法：

auto DataWrapper::getData()
{
    return dataStorage
        | std::ranges::views::transform(
            [](Data& d) -> MyInterface* { return &d; }
        );
}

但问题是，很明显这个访问器方法对其返回值是明确的 - 我需要知道这个方法返回这个列表，并且我担心在创建返回类型时auto，它会有点阻碍。看起来（我在这里可能是错的）你不应该知道 a 的类型view是什么（与 lambda 类似）

我正在考虑的替代方案是制作一个自定义视图（我可以使类型更加清晰），但重新实现标准中如此明确的东西确实让我很痛苦。对于这种情况，建议采取什么行动？现代 C++ 是否说我应该保留返回值auto？

文档说只有 3 个特殊的词法变量 ( ,$_ , $/) $!。

然而，检查 MY::pseudostash，似乎一个名为 的变量$¢也存在，并且没有记录（或者至少，在 docs.raku 中搜索 $¢ 没有结果）（编辑：根据接受的答案，这实际上是错误的，确实有记录）。

say MY::.hash;
# ==> PseudoStash.new((!UNIT_MARKER => (!UNIT_MARKER), $! => Nil, $/ => Nil, $=finish => (Mu), $=pod => [], $?PACKAGE => (GLOBAL), $_ => (Any), $¢ => Nil, &foo => &foo, ::?PACKAGE => (GLOBAL), EXPORT => (EXPORT), GLOBALish => (GLOBAL)))

sub foo {say MY::.hash}
foo();
# ==> PseudoStash.new(($! => Nil, $/ => Nil, $_ => (Any), $¢ => Nil))

$¢=5;
# The compiler doesn't complain, despite $¢ not having been declared

say $¢ 
# ==> 5

$¢有什么特殊的意义吗？

如果重要的话，我正在使用 rakudo v2023.12，实现 v6.d。

我有以下内容

library(tidyverse)
test <- tibble(A = c("1994:2020, 2021"), B = 1995)

我想检查 B 中的年份是否在 A 列中给出的年份中。A 列中的年份是一个字符串（数据是从 Excel 文件中读取的）。以下显然不起作用（它给出“否”，但我想要“是”）：

test %>%
  mutate(InA = ifelse(B %in% A, "Yes", "No"))

> test
# A tibble: 1 x 2
  A                   B
  <chr>           <dbl>
1 1994:2020, 2021  1995

我假设我必须分隔 A 中的字符串。但是，A 可以包含多个范围和/或超过一年（例如（“1994:2012, 2014, 2016:2020, 2021”）并使用“separate”对于不同的结构会变得复杂，也许有更简单的方法。

我想在映射例程中使用数组的索引。例如，这个 Raku 代码：

raku -e 'my @a = "First", "Second", "Third", "First"; say @a.map({ "Index of $_ is: ;" })'

印刷：

(Index of First is: ; Index of Second is: ; Index of Third is: ; Index of First is: ;)

是否可以获取数组的索引，例如：

(Index of First is: 0; Index of Second is: 1; Index of Third is: 2; Index of First is: 3;)

谢谢！

我有以下代码：

#include <print>
#include <vector>

int main() {
    std::vector<int> v{1, 2, 3};
    std::println("{}", v);
}

在这产生的众多错误中，有（clang++ -std=c++23 -stdlib=libc++，https://godbolt.org/z/3z9Tseh37）：

[...]/format_arg_store.h:167:17: error: static assertion failed due to [...]
  167 |   static_assert(__arg != __arg_t::__none, "the supplied type is not formattable");
      |                 ^~~~~~~~~~~~~~~~~~~~~~~~

这让我很困惑，因为根据cppreference C++23 编译器支持页面，libc++ 支持std::println并实现P2286: Formatting Ranges。

我做错了什么还是这是标准库错误？

以下代码打印nullptr而不是empty（godbolt 链接）：

#include <iostream>

class empty { };

#if 1
void f(std::nullptr_t) {
    std::cout << "nullptr\n";
}
#endif

void f(empty) {
    std::cout << "empty\n";
}

int main() {
    f({});
}

禁用f(nullptr_t)变体会导致empty打印。当两个变体都可用时，C++ 使用什么规则来选择nullptr_t变体？empty

我正在编写一个简单的 C++ 程序，它生成一个正态分布的随机整数值列表，然后获取前 N 个生成的项目并过滤它们，使它们的绝对值大于 42。我编写的代码如下：

int main() {
//convenience
    namespace rng = std::ranges;
    namespace view = std::views;
//random generation boilerplate
    std::random_device r;
    std::mt19937 gen(r());
    std::normal_distribution<float> taps(-4, 15);
 //the filtering   
    for (const auto& value : view::repeat(0)
        | view::transform([&taps, &gen](auto _) { return std::round(taps(gen)); })
        | view::take(1005)
        | view::filter([](auto val) { return (val < -42 || val > 42); }))
    {
        std::cout << value << ' ';
    }
    return 0;
}

如果我删除该view::filter行，则序列似乎完全正常，并且大约有 3 个左右的值满足条件。然而，当应用过滤器时，输出似乎是一些随机垃圾，例如-12 -8 -14 2 -4 -11 -38. 这有什么意义呢？这些数字甚至不满足过滤条件。任何帮助表示赞赏。

注意：在 Windows 和 Linux 上均
使用 编译。如果我用views::iota(0)替换views::repeat(0)并用 编译，输出是相同的——一些随机垃圾。另外，如果有人建议从 lambda 生成列表的更好方法，我将非常感激。g++ -o test main.cpp -std=c++2b
-std=c++20