小编ggu*_*lia的帖子

这似乎是一个重复的问题，但是我尝试了已经存在的解决方案，但到目前为止，对于我来说似乎没有任何解决方案。。

该解决方案给出了提示，但仅适用于常规几何体。我有一个相当复杂的几何图形，可以从中提取未排序的边界点。

下面是我从几何图形中提取的几何图形和边界顶点的图片。

如图所示，点的（x，y）坐标为：

import numpy as np

pts = np.array([[  30.        ,   -6.25      ],
                [  30.        ,   -8.10127917],
                [   0.        ,   -6.25      ],
                [  34.14082772,   -6.75584268],
                [  36.49784598,  -10.        ],
                [  44.43561524,  -10.        ],
                [ 100.        ,  -10.        ],
                [ 100.        ,   10.        ],
                [  84.1244615 ,  -10.        ],
                [  84.1244615 ,   10.        ],
                [  36.49784598,   10.        ],
                [  34.14082772,    6.75584268],
                [  44.43561524,   10.        ],
                [  30.        ,    8.10127917],
                [  30.        ,    6.25      ],
                [   0.        ,    6.25 …

cpp 参考页中指定的协程的第一个限制 是协程不能使用可变参数。但是当我尝试使用在其参数列表中接受可变参数的协程时，例如：

template<typename ...Args>
ReturnObject coro_with_variadic_argument1(Args ...args){
    std::cout << "size of variadic args: " << sizeof...(args) << "\n";
    co_await std::suspend_never{};
}

它在 GCC-11、Clang-14 中工作得很好，只有 MSVC-19 给出了一些排序警告，这些警告似乎与协程和可变参数没有任何关系，并在警告后打印输出。请参阅编译器资源管理器上的代码。那么 cppreference 页面中的以下语句到底是什么意思：

协程不能使用可变参数...

有没有例子表明使用可变参数创建 C++ 协程是非法的？

return_void

考虑下面的协程ReturnObject并注意方法之前的注释ReturnObject::promise_type::return_void：

struct ReturnObject {
        struct promise_type {
            int val_{23};
            ReturnObject get_return_object() {
                return {std::coroutine_handle<promise_type>::from_promise(*this)}; 
            }
        std::suspend_never initial_suspend() { return {}; }
        std::suspend_never final_suspend() noexcept { return {}; }
        void unhandled_exception() {}

         /*** NOTE THIS ***/
        //void return_void(){  }
        
        /*** AND THIS ***/
        int return_void(){ return 101; }
      };
      
      std::coroutine_handle<promise_type> h_; 
      ReturnObject(std::coroutine_handle<promise_type> h):h_{h}{ } 
      operator std::coroutine_handle<promise_type>() const { return h_; } 
};

编译器资源管理器上的完整代码

网络上和本文（第 37 页）中的标准用法表明该return_void方法返回void，但在 gcc 11.2 中，return_void …

我正在尝试创建一个网格网格，而没有落入具有指定坐标和半径的圆内的某些点。我无法减去落入圆内的网格点。这是我的代码

import math
import numpy 
import matplotlib.pyplot as plt


N = 50
x_start, x_end = -2.0, 2.0 
y_start, y_end = -1.0, 1.0


x = numpy.linspace(x_start, x_end, N)
y = numpy.linspace(y_start, y_end, N)

circle_x, circle_y, r= 0.0, 0.0, 0.4

#x.remove((r-circle_x)**2)   #need some help with these two lines
#y.remove((r-circle_y)**2)


X, Y = numpy.meshgrid(x, y)


size = 10
fig = plt.figure()
plt.xlabel('x', fontsize = 16)
plt.ylabel('y', fontsize = 16)
plt.scatter(X, Y)
plt.show()

显示网格点的meshgrid ##标题

我正在阅读C++17 - The Complete Guide 一书，在constexprlambda 的6.1 节中，作者给出了两个例子：

auto squared1 = [](auto val) constexpr { // example 1. compile-time lambda calls
  return val * val;
};

和

constexpr auto squared2 = [](auto val) { // example 2. compile-time initialization
  return val * val;
};

并说这两个彼此不同，因为示例 1在编译时评估，示例 2在编译时初始化。

然后作者做了以下我不完全理解的陈述：

如果（仅）lambda 是constexpr它可以在编译时使用，但是如果由 lambda 初始化的（闭包）对象是constexpr，则该对象在程序启动时被初始化，但 lambda 可能仍然是一个只能在以下情况下使用的 lambda运行时（例如，使用静态变量）。因此，您可以考虑声明：

constexpr auto squared = [](auto val) constexpr { // example 3
  return val …

Run Code Online (Sandbox Code Playgroud)

我在理解类型何时推导出std::ranges::dangling何时使用命名局部变量与纯右值作为std::ranges::sort算法的参数时遇到问题。例如，我有一个函数将 a 返回prvalue 到标准容器，比如 std::vector ，我直接将其用作 的参数std::ranges::sort，然后我期望std::ranges::dangling在尝试取消引用迭代器时收到编译错误，这就是我得到的：

#include <vector>
#include <algorithm>

auto get_data(){
    return std::vector<int>{1, 2, 99, 5, 9, 4};
}

auto get_sorted(){
    return std::ranges::sort(get_data());
}


int main(){
    auto it = get_sorted();
    *(it-1); //Compiler Error because it is a std::ranges::dangling iterator
}

但是，如果我稍微更改get_sorted上面的函数以首先捕获命名变量中的向量并使用它来返回 的结果std::ranges::sort，那么我不会得到悬空迭代器，即使main命名变量中分配的向量应该是函数get_sorted返回后销毁：

auto get_sorted(){
    auto vec = get_data();
    return std::ranges::sort(vec);
}


int main(){
    auto it = get_sorted();
    *(it-1); //Okay result  = …