小编Apo*_*ica的帖子

我想知道 Ruby 中是否有一种方法可以使用类似于 python 的方式使用单词作为运算符编写一行 if-then-else 语句

a if b else c

我知道经典的三元条件，但我感觉 Ruby 更像是一种“wordsey”语言而不是“symboley”语言，所以我试图更好地封装语言的精神。

这个方法我也知道，

if a then b else c end

这基本上是将多线压扁到一条线上，但线end的末端感觉繁琐和多余。我认为三元条件会比这个更可取。

那么对于熟悉 Ruby 的你来说，有没有更好的写法呢？如果不是，哪种方法最像 Rubyesque？

链接的帖子未解决以下问题：

1. 有没有比if a then b else c end在 Ruby 中编写“wordsey”单行 if-then-else 更简洁的方法？
2. 三元条件或 wordsey 版本更适合 Ruby 范式吗？

在我的 bazelBUILD文件中，有一行：

srcs = glob([<pattern1>, <pattern2>, ...])

我试图让我的模式之一成为，"../dir/*.cc"但出现错误，不允许我..在此处使用该序列。

检查文档，我发现这是不允许的，但我不确定预期的替代品是什么。

同样，禁止上级引用 (..) 和当前目录引用 (./)。

考虑到我当前的文件结构，如何将这些其他源文件包含在我的srcs列表中？如果我无法引用上层目录，有没有办法使用其他目录的包名来代替？

这里发生了什么？

>>> a = np.int8(1)
>>> a%2
1
>>> a = np.uint8(1)
>>> a%2
1
>>> a = np.int32(1)
>>> a%2
1
>>> a = np.uint32(1)
>>> a%2
1
>>> a = np.int64(1)
>>> a%2
1
>>> a = np.uint64(1)
>>> a%2
'1.0'

我们突然得到一个似乎是一个包含浮子的字符串! 1.0

>>> a = np.uint64(1)
>>> type(a%2)
<type 'numpy.float64'>

......虽然事实证明它只是一个漂浮物.

这背后的哲学是什么？

我知道numpy想要更严格的类型和打字规则之类的东西,以便比基本的python更有效,但在这种情况下,向用户返回一个非常意外的结果(可能会破坏他们的程序)的缺点似乎远远超过在沿着这条湿滑路径徘徊之前,仅仅检查模数符号的成本略有增加.

处理uint64价值观并不是很少见.例如,如果您将图像加载到numpy int数组中然后对其求和,则可以使用uint64(s).另一方面,用负数来修改任何东西是非常罕见的(除了看看会发生什么之外,我从来没有做过),因为你通常会修改你可以计算的东西,比如索引,以及不同的语言/标准/库每个人都可以对结果应该有自己的想法.

所有这些放在一起让我感到困惑.

我已经用谷歌搜索了几个月试图解决这个问题，但我尝试过的都没有效果。

所以一个简单的程序是这样的：

#include <concepts>
#include <iostream>

int main() {
    std::cout << "Test" << std::endl;
    return 0;
}

无法编译并显示错误消息fatal error: 'concepts' file not found。clang++ 和 g++ 编译器都会发生这种情况。（为了完整性：clang++-11 -std=c++20 test.cpp和g++ -std=c++2a test.cpp。）

我的编译器版本是：

> clang++-11 --version
Ubuntu clang version 11.0.0-2~ubuntu20.04.1

> g++ --version
g++ (Ubuntu 9.3.0-17ubuntu1~20.04) 9.3.0

如果我寻找我的 C++ 头文件，我可以在以下位置找到它们/usr/include/c++：

> find /usr -name "iostream"
/usr/lib/llvm-10/include/c++/v1/iostream
/usr/include/c++/9/iostream

然而，find /usr -name "concepts"什么也没给出。所以标题肯定丢失了。连同所有其他特定于 C++20 的标头，以及在其他标头中定义的特定于 C++20 的函数（例如[std::bit_width][1]- 可以包含标头，但未定义函数）。

顺便说一句，我可以使用所有 C++20功能。例如，我可以定义自己的概念，尽管我不能使用概念标题。 …

我在constexpr 这里读到:

该constexpr指定符,它可以评估在编译时函数或变量的值.

当我第一次阅读这句话时,它对我来说非常有意义.但是,最近我遇到了一些完全让我失望的代码.我重建了一个简单的例子如下:

#include <iostream>

void MysteryFunction(int *p);

constexpr int PlusOne(int input) {
  return input + 1;
}

int main() {
  int i = 0;
  MysteryFunction(&i);
  std::cout << PlusOne(i) << std::endl;

  return 0;
}

看看这段代码,我无法说出PlusOne(i)应该是什么结果,但它实际上是编译的!(当然链接会失败,但g++ -std=c++11 -c成功没有错误.)

什么是"可以在编译时评估函数值的正确解释"？

我遇到了以下形式的奇怪代码：

// Given the following definitions:
class B;
B b;

// Line of interest:
auto a(b);

我以为它一定是拼写错误，但是经过一些实验发现它是可行的，并且似乎总是调用type的copy构造函数b（即使您有其他也可以具有匹配构造函数的类，即使您另外删除类型为的复制构造函数b。

我不知道这样一条语句的技术名称，所以我不确定如何在cppreference或StackOverflow中搜索它。编译器通常如何解析这种类型的语句，它在哪里记录？

-

回复：重复标记。我看不出他们如何解决这个问题。我已经知道auto使用模板类型推导，在这种情况下并不能说明任何事情。

以类似的方式

select * from mytable where rownum <= 1000;

会给我查询的前 1000 行结果，有没有办法

select * from mytable where runtime <= 1000;

它将返回运行查询的前 1000 个 <时间单位> 中获得的结果？

给定两个std::vector<T>s 和vec_a，vec_b标准库是否包含一个函数来测试 中的每个元素vec_a是否小于 中其位置对应的元素vec_b（假设二进制文件operator<是为类型 的操作数定义的T）？

我认为像二元谓词版本这样的东西std::all_of可以完美地完成这个任务，但我不确定它是否存在，或者如果存在的话它会被称为什么。如果存在这种情况，也许std::all_of应用于执行元素比较的另一个函数的输出的某种组合也可以工作。

所需功能的示例：

std::vector<int> vec_a{1, 2, 3};
std::vector<int> vec_b{2, 3, 4};

bool all_less = vec_a.size() == vec_b.size();
for (size_t i = 0; all_less && (i < vec_a.size()); ++i) {
    all_less = vec_a[i] < vec_b[i];
}

// all_less now holds desired result

给定一个迭代器it,我想要一个函数it_count,它返回迭代器产生的元素数,而不会破坏迭代器.例如:

ita = iter([1, 2, 3])
print(it_count(ita))
print(it_count(ita))

应该打印

3
3

有人指出,对于所有迭代器来说,这可能不是一个明确定义的问题,所以我不是在寻找一个完全通用的解决方案,但它应该在给定的例子中按预期运行.

好的,让我进一步澄清我的具体案例.给出以下代码:

ita = iter([1, 2, 3])
itb, itc = itertools.tee(ita)
print(sum(1 for _ in itb))
print(sum(1 for _ in itc))

...我们可以编写it_count上面描述的函数,以便它以这种方式运行吗？即使问题的答案是"无法做到",这仍然是一个完全有效的答案.它不会让问题变得糟糕.并且证明它是不可能的将远非微不足道的......

如何编写一个与vanilla指针类型(T*)或在<memory>诸如std::unique_ptr？中定义的特殊指针类型兼容的函数？

我尝试使用std::is_pointer检查,但看起来这不是正确的方法:

#include <iostream>
#include <memory>

template<typename T>
void SomePointerFunction(
     T p, typename std::enable_if<std::is_pointer<T>::value>::type* = nullptr) {
  std::cout << (p ? "not null" : "null") << std::endl;
}

int main() {
  int* p;
  std::unique_ptr<int> q;
  SomePointerFunction(p); // If we cange p to q, template matching fails

  return 0;
}

是否有某种通用指针类型在C++中定义,可以封装这些不同类型的指针,或不同的模板检查,实现这一点？

在考虑了更多之后,我也理解为什么这实际上是语言的一个不受欢迎的特性,因为这两种类型的指针在很多方面都非常不同.但是,如果您只想编写一个利用指针解除引用属性的函数,那么这可能是有用的似乎是合理的.有没有办法说"这个函数需要一个参数,为其*定义运算符"？

关于访问std::set索引中的元素,这个网站上有几个问题,但我看到的答案是旧的,没有启发性.

有序集可以(并且通常)实现为二叉搜索树.在二叉搜索树中,通过存储以每个节点为根的树中的节点数,我们可以及时k按排序顺序访问第th个元素,O(log n)而不会增加其他操作的算法复杂度(如果这是我的错误,请纠正我.思维).

然而,如果我想要k从a排序的th元素set::set,我必须从begin()一直走到k,使用O(k)时间代替.一般来说,这可能等同于O(n)时间.

所以,我的问题是:

• 我们是否可以维护一个高度平衡的二叉搜索树是否正确,在该树中可以及时找到第三k个元素O(log n)而不会损害其他操作的时间复杂度？
• 如果是这样,C++标准库中是否有一个函数或备用数据结构可以用于此效果？
• 如果对前者是肯定而对后者不对,那么它是否被考虑过？是否由于某些技术障碍或仅仅因为实施成本对于此功能的潜在效用而言太昂贵而未实施？

C++语言有关于如何释放指针所指向的内存的特定规则.这些规则要求您知道如何分配内存以正确释放它.

例如,

int *p = new int();
std::free(p);

导致未定义的行为.(参考)

在现代C++中,我们喜欢尽可能使用智能指针,但有时我们可能希望使用分配原始指针的库或函数.假设我想使用以下形式的函数:

char* NotMyFunction();

如何正确管理此功能分配的内存？