小编Reg*_*gus的帖子

有很多基于公式的解决方案可用于从 Excel 中的列、行或连续范围中查找最后一个非空单元格值，例如，对于列，最流行的是=LOOKUP(2,1/(A:A<>""),A:A)和=LOOKUP(2,1/(NOT(ISBLANK(A:A))),A:A)。这很好，但它只适用于连续范围。然而，有时，您需要对断开连接的单元格列表或单元格范围而不是单个连续范围执行相同的操作。因此，如果有一个假设的函数FINDLASTNONBLANK()，它的调用将如下所示：

对于任意长的单细胞列表

=FINDLASTNONBLANK(A1, D1, F1)
=FINDLASTNONBLANK(A1, D1, F1, X1)

对于任意长的范围列表

=FINDLASTNONBLANK(A1:A4, A10:A15)
=FINDLASTNONBLANK(A1:A4, A10:A15, A20:A25)

显然，没有这样的现成公式，所以我想知道是否有办法为此炮制基于公式的解决方案。没有 VBA UDF。

到目前为止，我正在朝着以下方向思考：如果我可以编写一种公式来将断开连接的单元格/范围连接到一个范围/数组中，那么也许我可以使用经典的黑客=LOOKUP(2,1/(A:A<>""),A:A)，就像这样（假设假设的公式JOINRANGES()或假设的聚合语法{,}） ：

=LOOKUP(2,1/(JOINRANGES(A1:A4,A10:A15)<>""),JOINRANGES(A1:A4,A10:A15))
=LOOKUP(2,1/({A1:A4,A10:A15}<>""),{A1:A4,A10:A15})

那么，Excel 中是否有一种语法可以从我不知道的不相交单元格/范围/数组列表中指定数组？如果有，它应该至少向后兼容 Excel 2007。

我可以将解决方案限制为一维数据源（仅行，仅列），而不必在二维矩阵上工作。事实上，我可以选择仅处理同一行（甚至不是列）的不相交数据的解决方案。

当我开始利用C++ 17结构化绑定和if运算符init语句以获得更优雅的函数结果报告和检查时,如果符合C++ Core Guideline F21,我开始执行以下操作:

std::pair<bool, int>Foo()
{
    return {true, 42}; //true means that function complete with no error and that 42 is a good value
}

void main(void)
{
    if (auto [Result, Value] = Foo(); Result)
    {
        //Do something with the return value here
    }
}

然后,当然,我觉得为这样的返回类型设置一个可重用的模板会很好,所以没有人必须复制该对的bool部分:

template <typename T> using validated = std::pair<bool,T>;

validated<int> Foo()
{
    return {true, 42};
}

void main(void)
{
    if (auto [Result, Value] = Foo(); Result)
    {
        //Do something with the return value here …

考虑以下简单的 C/C++ 示例：

#define FOO
...
#ifdef FOO
  bar++;
#endif

好的，现在我想将该条件（以及任何其他类似的）条件放入一行中，以提高代码可读性（该代码有数十个单行语句，每个语句都需要有条件，每个语句取决于不同的定义）。使用时，看起来像这样：

#define FOO
...
MY_IFDEF(FOO,bar++;) //Single-line conditional

目标是拥有一个可重用的宏，它可以采用任意标识符，并且如果该标识符之前已被 #define-d 编译该语句，并在一行中完成所有操作。

有任何想法吗？

UPDATE0：代码必须针对 C 和 C++ 进行编译

我试图优雅地声明一个常量std::set对象，它将是另外两个常量std::set对象的合并。

#include <set>

const std::set<int> set_one = { 1,2,3 };
const std::set<int> set_two = { 11,15 };
const std::set<int> set_all = { 1,2,3,11,15 }; // this is not very elegant, duplication

以set_all这种方式声明对象不太优雅，因为它复制了前两行的信息。有没有办法在声明中使用set_one和set_two常量set_all？

像这样的东西：

const std::set<int> set_all = set_one + set_two; // this does not compile, of course!

1. 所有对象都是严格的常量。
2. 两个源集中没有重叠值，因此唯一性不会成为问题。
3. 我知道如何在运行时合并集合，这不是我要找的。
4. 我真的很想避免使用这样的宏：

#include <set>

#define SET_ONE 1, 2, 3
#define SET_TWO 11, 15

const std::set<int> set_one = { SET_ONE …

考虑这个简单的类派生自std::variant：

#include <string>
#include <variant>

class my_variant : public std::variant<int, std::string>
{
    using variant::variant;
public:
    std::string foo()
    {
        return "foo";
    }
};

请注意，我故意添加using variant:variant以便在派生类中公开基类的构造函数。如果不这样做，类的实例将无法 在没有大量重新定义的情况下my_variant工作。operator=这编译得很好。

现在让我们开始逐步将其变成模板。

template <typename TChr>
class my_variant : public std::variant<int, std::string>
{
    using variant::variant;

public:
    // Changed to templated return type, compiles fine
    std::basic_string<TChr> foo() 
    {
        return "foo";
    }
};

在这里，唯一的变化是我们在方法中使用了模板参数foo()。一切仍然编译良好。

现在这个：

template <typename TChr>
class my_variant : // Changed to templated base class
    public std::variant<int, …

考虑以下 C++ 代码：

struct My_Struct
{
  int a;
  int b;
};

现在我想声明这些结构的常量 std::array ：

选项A：

const std::array<My_Struct,2> my_array =
{
  {1,2},
  {2,3}
};

选项B：

const std::array<My_Struct,2> my_array =
{
  My_Struct(1,2),
  My_Struct(2,3)
};

问题：为什么选项A无法编译而只有选项B可以编译？初始化 std::array 时嵌套花括号有什么问题？

在我看来，编译器应该拥有成功编译选项 A 所需的所有信息，但它会产生“太多初始值设定项值”错误。

同时，嵌套花括号在初始化普通数组时效果非常好：

const My_Struct my_array[] =
{
      {1,2},
      {2,3}
};

编译器是MSVC 17.2，C++20模式。

我可以接受选项 B，但我想了解在 C++ 知识方面我在选项 A 中到底无法理解什么。