小编Sym*_*ink的帖子

我正在尝试编写可以索引到例如 an 的类型的类型特征std::vector，其中应该包括枚举类型，因为我可以将它们转换为它们的基础类型。

到目前为止我已经写了以下特征。

#include <iostream>
#include <type_traits>
#include <cinttypes>
#include <vector>
#include <utility>

template<typename T>
struct is_unsigned_integral :
    std::integral_constant<
        bool,
        std::is_integral<T>::value &&
        std::is_unsigned<T>::value
    > {};

template<typename T>
inline constexpr auto is_unsigned_integral_v = 
    is_unsigned_integral<T>::value;

template<typename, typename = void>
struct is_index : std::false_type {};

template<typename T>
struct is_index<
    T, 
    std::enable_if_t<
        is_unsigned_integral_v<
            std::conditional_t<
                std::is_enum_v<T>,
                std::underlying_type_t<T>,
                T
            >
        >
    >
> : std::true_type {};

template<typename T>
inline constexpr auto is_index_v = is_index<T>::value;

enum class idx : unsigned int {};

int main() …

有没有办法使用 c++20s 概念来检查值是否满足某些要求？

假设我正在编写某种使用分页的容器，并且我想让页面大小成为模板参数。

template<typename Type, std::size_t PageSize>
class container;

我可以使用带有 constexpr 函数的静态断言来检查PageSize类体内是否为 2 的幂。

但有没有办法用新观念来约束呢PageSize？

我正在尝试构建一个具有以下目录结构的库：

lib1
|-include
| |-lib1
|   |-public.h
|-src
| |-private.h
| |-private.cpp
| |-public.cpp
|-lib
| |-liblib1.a
|-CMakeLists.txt

公共标头包含私有标头以使用其功能。

我的CMakeLists.txt样子如下：

project(math)

set(SRC_FILES src/private.cpp src/public.cpp)

add_library(${PROJECT_NAME} STATIC ${SRC_FILES})

target_include_directories(
    ${PROJECT_NAME}
    PUBLIC
        "${CMAKE_CURRENT_SOURCE_DIR}/include"
    PRIVATE
        "${CMAKE_CURRENT_SOURCE_DIR}/src"
)

set_target_properties(
    ${PROJECT_NAME}
    PROPERTIES 
    ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/lib"
)

但是当我尝试构建库时，我收到一个错误，public.h说没有文件private.h

当谷歌搜索时，我要么找到不使用的相当旧的帖子，target_include_directories要么它们通过将所有文件放在同一目录中来支持不干净的结构

我有某种模板化基类

template<typename Derived>
class Base { };

并希望将其派生实例存储在列表中。为此，我使用using derived_handle = std::unique_ptr<void, void(*)(void*)别名。

当我现在将派生实例添加到列表中时，我可以使用静态成员函数作为删除器

class foo {

  template<typename Derived, typename... Args>
  void add_base(Args&&... args) {
    auto derived = derived_handle{new Base{std::forward<Args>(args)..., &foo::_deleter<Derived>};

    _derived.emplace_back(std::move(derived));
  }

private:

  template<typename Baser>
  void _deleter(void* base) {
    delete static_cast<Base*>(base);
  }

  std::vector<derived_handle> _derived{}; 

};

或 lambda

class foo {

  template<typename Derived, typename... Args>
  void add_base(Args&&... args) {
    auto deleter = [](auto* derived){
      delete static_cast<Derived*>(derived);
    }

    auto derived = derived_handle{new Base{std::forward<Args>(args)..., std::move(deleter)};

    _derived.emplace_back(std::move(derived));
  }

private:

  std::vector<derived_handle> _derived{}; 

}; …

我想与 std::async 并行执行多项任务，然后等到所有期货都完成。

void update() {
  // some code here
}

int main() {

  std::vector<std::future<void>> handles(5);

  for (int i = 0; i < 5; ++i) {
    auto handle = std::async(std::launch::async, &update);
    handles.emplace_back(std::move(handle));
  }

  for (auto& handle : handles) {
    handle.wait();
  }

  return 0;
}

但是在执行程序时，我得到了一个std::future_error抛出：

terminate called after throwing an instance of 'std::future_error'
  what():  std::future_error: No associated state
Aborted (core dumped)

我想知道为什么。我不应该能够存储未来的对象吗？