首页
/ MyTinySTL模板元编程技巧

MyTinySTL模板元编程技巧

2026-02-04 04:44:35作者：乔或婵
MyTinySTL
Achieve a tiny STL in C++11
项目地址：https://gitcode.com/gh_mirrors/my/MyTinySTL

本文深入解析了MyTinySTL中运用的现代C++模板元编程核心技术，包括SFINAE与enable_if类型约束、type_traits类型特性萃取、可变参数模板与完美转发、以及移动语义与右值引用优化。这些技术共同构成了MyTinySTL高效、类型安全且灵活的基础架构，通过编译时计算和类型推导实现了显著的性能提升和代码优化。

SFINAE与enable_if类型约束

在MyTinySTL的实现中，SFINAE（Substitution Failure Is Not An Error）和std::enable_if被广泛用于模板元编程中的类型约束和条件编译。这种技术使得模板能够根据类型特性选择不同的实现路径，是现代C++模板编程的核心技术之一。

SFINAE机制原理

SFINAE是C++模板元编程中的一项重要特性，当模板参数替换失败时，编译器不会报错，而是简单地从候选函数集中移除该模板特化。MyTinySTL充分利用这一机制来实现类型安全的模板函数重载。

flowchart TD
    A[模板函数调用] --> B{模板参数替换}
    B -->|成功| C[选择该重载版本]
    B -->|失败| D[从候选集中移除]
    D --> E{还有其他重载?}
    E -->|是| B
    E -->|否| F[编译错误]

enable_if的基本用法

std::enable_if是SFINAE技术的典型应用，它根据编译期布尔条件来启用或禁用模板特化。在MyTinySTL中，enable_if主要用于：

  1. 类型特征检查 - 验证类型是否满足特定要求
  2. 重载决议 - 根据类型特性选择不同的函数实现
  3. 接口约束 - 限制模板参数的有效类型范围

MyTinySTL中的enable_if应用实例

1. 拷贝操作的类型优化

在algobase.h中，unchecked_copy函数为平凡可拷贝类型提供了优化版本：

template <class Tp, class Up>
typename std::enable_if<
  std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
  std::is_trivially_copy_assignable<Up>::value,
  Up*>::type
unchecked_copy(Tp* first, Tp* last, Up* result)
{
  const auto n = static_cast<size_t>(last - first);
  if (n != 0)
    std::memmove(result, first, n * sizeof(Up));
  return result + n;
}

这个实现使用了enable_if来确保只有在以下条件满足时才启用该特化：

  • 源类型和目标类型相同（去除const限定符后）
  • 类型是平凡可拷贝赋值的

2. 迭代器类型区分

在容器实现中，enable_if用于区分输入迭代器和随机访问迭代器：

template <class Iter, typename std::enable_if<
  mystl::is_input_iterator<Iter>::value, int>::type = 0>
void assign(Iter first, Iter last)
{
  // 输入迭代器版本的实现
}

template <class Iter, typename std::enable_if<
  mystl::is_random_access_iterator<Iter>::value, int>::type = 0>
void assign(Iter first, Iter last)
{
  // 随机访问迭代器版本的实现
}

3. pair类的构造约束

在util.h中，pair类的构造函数大量使用了enable_if来实现精细的类型控制：

template <class U1 = Ty1, class U2 = Ty2,
  typename std::enable_if<
  std::is_copy_constructible<U1>::value &&
  std::is_copy_constructible<U2>::value &&
  std::is_convertible<const U1&, Ty1>::value &&
  std::is_convertible<const U2&, Ty2>::value, int>::type = 0>
constexpr pair(const Ty1& a, const Ty2& b)
  : first(a), second(b)
{
}

这个构造函数只有在类型可拷贝构造且可转换时才可用。

enable_if的技术细节

返回值类型控制

enable_if最常见的用法是控制模板函数的返回类型：

template <class T>
typename std::enable_if<std::is_integral<T>::value, T>::type
process(T value) {
  return value * 2;
}

模板参数默认值控制

通过模板参数的默认值来实现SFINAE：

template <class T, 
          typename = typename std::enable_if<std::is_class<T>::value>::type>
void process_class(T obj) {
  // 只对类类型有效
}

函数参数类型控制

使用额外的函数参数来实现条件启用：

template <class T>
void process(T value, 
             typename std::enable_if<std::is_arithmetic<T>::value, int>::type = 0) {
  // 只对算术类型有效
}

SFINAE在MyTinySTL中的设计模式

MyTinySTL中SFINAE的应用遵循几个典型模式：

模式类型 应用场景 示例
类型特征检查 验证模板参数特性 std::is_integral<T>::value
重载选择 根据迭代器类别选择算法 输入迭代器 vs 随机访问迭代器
接口约束 限制构造函数可用性 pair的不同构造函数版本
优化路径 为特定类型提供优化实现 平凡类型的memcpy优化

实际应用案例分析

让我们分析一个具体的例子，看看MyTinySTL如何利用SFINAE实现智能的类型分发：

// 通用版本 - 用于非平凡类型
template <class InputIter, class OutputIter>
OutputIter copy(InputIter first, InputIter last, OutputIter result) {
  for (; first != last; ++first, ++result) {
    *result = *first;
  }
  return result;
}

// 优化版本 - 用于平凡可拷贝类型
template <class Tp, class Up>
typename std::enable_if<
  std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
  std::is_trivially_copy_assignable<Up>::value,
  Up*>::type
copy(Tp* first, Tp* last, Up* result) {
  size_t n = last - first;
  if (n > 0) {
    memmove(result, first, n * sizeof(Up));
  }
  return result + n;
}

这种设计使得：

  1. 对于平凡类型（如基本数据类型），使用高效的memmove
  2. 对于非平凡类型，使用安全的逐个元素拷贝
  3. 编译期自动选择最优实现，无需运行时判断

最佳实践总结

MyTinySTL中SFINAE和enable_if的使用体现了现代C++模板元编程的最佳实践：

  1. 明确的错误消息 - 通过静态断言提供清晰的编译错误信息
  2. 渐进式接口 - 从最宽松的约束开始，逐步添加更严格的约束
  3. 性能优化 - 为特定类型特性提供优化实现
  4. 类型安全 - 编译期类型检查避免运行时错误
classDiagram
    class TemplateFunction {
        +enable_if条件
        +SFINAE机制
        +编译期选择
    }
    class TypeTraits {
        +is_integral
        +is_class
        +is_convertible
    }
    class Optimization {
        +平凡类型优化
        +memmove使用
        +性能提升
    }
    
    TemplateFunction --> TypeTraits : 依赖
    TemplateFunction --> Optimization : 实现

通过SFINAE和enable_if，MyTinySTL实现了高度泛化且类型安全的模板代码，同时保持了优秀的运行时性能。这种技术是现代C++库开发的基石，值得每个C++开发者深入理解和掌握。

type_traits类型特性萃取技术

在现代C++模板元编程中，类型特性萃取（Type Traits）是一项核心技术，它允许我们在编译时获取和操作类型信息。MyTinySTL通过精心设计的type_traits系统，为整个STL实现提供了强大的类型信息处理能力。

基础类型特性设施

MyTinySTL构建了一套基础的类型特性设施，作为编译时类型信息查询的基石：

// 基础积分常量模板
template <class T, T v>
struct m_integral_constant
{
  static constexpr T value = v;
};

// 布尔常量类型别名
template <bool b>
using m_bool_constant = m_integral_constant<bool, b>;

// 真假类型定义
typedef m_bool_constant<true>  m_true_type;
typedef m_bool_constant<false> m_false_type;

这个基础架构提供了编译时常量和类型标签机制，是构建更复杂类型特性的基础。

自定义类型特性实现

MyTinySTL实现了多种自定义类型特性，其中最典型的是is_pair特性：

// 前向声明
template <class T1, class T2>
struct pair;

// is_pair类型特性
template <class T>
struct is_pair : mystl::m_false_type {};

template <class T1, class T2>
struct is_pair<mystl::pair<T1, T2>> : mystl::m_true_type {};

这种特化模式展示了类型特性萃取的核心思想：通过模板特化来区分不同类型的特性。

标准库类型特性的集成应用

MyTinySTL大量使用了C++11标准库的类型特性，实现了各种编译时检查和优化：

类型安全检查

// 在vector中禁止bool特化
static_assert(!std::is_same<bool, T>::value, "vector<bool> is abandoned in mystl");

// 在basic_string中要求POD类型
static_assert(std::is_pod<CharType>::value, "Character type must be POD");

异常安全保证

// 移动构造函数的异常安全声明
queue(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value);

// 移动赋值运算符的异常安全声明  
queue& operator=(queue&& rhs) noexcept(std::is_nothrow_move_assignable<Container>::value);

算法优化

// 在algobase中使用类型特性进行优化选择
std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
std::is_trivially_copy_assignable<Up>::value,

类型特性在容器中的应用

红黑树中的类型区分

template <class T>
struct rb_tree_value_traits
{
  static constexpr bool is_map = mystl::is_pair<T>::value;
  typedef rb_tree_value_traits_imp<T, is_map> value_traits_type;
};

哈希表中的类型处理

template <class T>
struct ht_value_traits
{
  static constexpr bool is_map = mystl::is_pair<T>::value;
  typedef ht_value_traits_imp<T, is_map> value_traits_type;
};

编译时类型特性查询机制

MyTinySTL的类型特性系统支持丰富的编译时查询：

特性类别 示例 用途
类型比较 std::is_same<T, U> 判断两个类型是否相同
类型转换 std::remove_const<T> 移除类型的const限定符
类型属性 std::is_integral<T> 判断是否为整型
构造特性 std::is_constructible<T, Args...> 判断是否可构造
异常特性 std::is_nothrow_move_constructible<T> 判断移动构造是否不抛异常

类型特性萃取的实现模式

MyTinySTL展示了多种类型特性实现模式：

graph TD
    A[基础类型特性] --> B[m_integral_constant]
    B --> C[m_bool_constant]
    C --> D[m_true_type]
    C --> E[m_false_type]
    
    F[自定义特性] --> G[主模板-默认false]
    G --> H[特化模板-特定类型true]
    
    I[标准库集成] --> J[类型检查]
    I --> K[异常安全]
    I --> L[算法优化]

实际应用示例

// 使用类型特性进行编译时分发
template <typename T>
void process_value(T value)
{
    if constexpr (std::is_integral_v<T>) {
        // 整数类型的处理
        std::cout << "Integral value: " << value << std::endl;
    } else if constexpr (mystl::is_pair_v<T>) {
        // pair类型的处理
        std::cout << "Pair: (" << value.first << ", " << value.second << ")" << std::endl;
    } else {
        // 其他类型的处理
        std::cout << "Other type" << std::endl;
    }
}

性能优化与安全保证

类型特性萃取技术在MyTinySTL中发挥了关键作用：

  1. 编译时优化：通过类型特性选择最优的实现路径
  2. 类型安全：在编译期捕获类型错误，避免运行时问题
  3. 异常安全：基于类型特性提供准确的异常安全保证
  4. 代码生成：根据类型特性生成特化代码，提高性能

这种类型特性萃取技术的应用，使得MyTinySTL能够在保持代码简洁性的同时，实现高度的类型安全和性能优化。

可变参数模板与完美转发

在C++11标准中引入的可变参数模板（Variadic Templates）和完美转发（Perfect Forwarding）是现代C++模板元编程中两个极其重要的特性。MyTinySTL项目充分利用了这两个特性来实现高效、灵活的容器和算法设计。

可变参数模板基础

可变参数模板允许模板接受任意数量和类型的参数，语法上使用...来表示参数包。在MyTinySTL中，可变参数模板被广泛应用于各种容器构造和元素操作中。

// 可变参数模板的基本语法
template <class... Args>
void function(Args&&... args) {
    // 处理任意数量和类型的参数
}

在STL容器中，可变参数模板最常见的应用是emplace系列函数，它们可以直接在容器内部构造元素，避免了不必要的拷贝或移动操作：

// vector中的emplace_back实现
template <class... Args>
void emplace_back(Args&&... args) {
    if (end_ != cap_) {
        data_allocator::construct(mystl::address_of(*end_), 
                                 mystl::forward<Args>(args)...);
        ++end_;
    } else {
        reallocate_emplace(end_, mystl::forward<Args>(args)...);
    }
}

完美转发机制

完美转发是确保函数参数在传递过程中保持其原始值类别（左值或右值）的技术。MyTinySTL在util.h中实现了自己的forward函数：

template <class T>
T&& forward(typename std::remove_reference<T>::type& arg) noexcept {
    return static_cast<T&&>(arg);
}

template <class T>
T&& forward(typename std::remove_reference<T>::type&& arg) noexcept {
    static_assert(!std::is_lvalue_reference<T>::value, "bad forward");
    return static_cast<T&&>(arg);
}

这两个重载版本分别处理左值引用和右值引用的情况，确保参数能够正确地转发到目标函数。

参数包展开技术

可变参数模板的核心在于参数包的展开。MyTinySTL使用了多种参数包展开技术：

// 递归展开示例
template <class T>
void process(T&& arg) {
    // 处理单个参数
}

template <class First, class... Rest>
void process(First&& first, Rest&&... rest) {
    process(mystl::forward<First>(first));  // 处理第一个参数
    process(mystl::forward<Rest>(rest)...); // 递归处理剩余参数
}

// 折叠表达式（C++17特性，MyTinySTL中未使用但值得了解）
template <class... Args>
auto sum(Args&&... args) {
    return (args + ...); // 折叠表达式
}

在容器中的应用实践

MyTinySTL中的各个容器都充分利用了可变参数模板和完美转发：

// hashtable中的emplace实现
template <class... Args>
iterator emplace_multi(Args&&... args) {
    auto np = create_node(mystl::forward<Args>(args)...);
    // ... 后续处理
}

// pair构造函数的完美转发
template <class Other1, class Other2>
constexpr pair(Other1&& a, Other2&& b)
    : first(mystl::forward<Other1>(a)),
      second(mystl::forward<Other2>(b)) {}

类型推导与转发引用

完美转发依赖于模板参数推导和转发引用（Universal References）的概念：

flowchart TD
    A[函数调用] --> B[模板参数推导]
    B --> C{参数类型判断}
    C -->|左值| D[推导为左值引用]
    C -->|右值| E[推导为右值引用]
    D --> F[forward保持左值性]
    E --> G[forward保持右值性]
    F --> H[目标函数接收左值]
    G --> I[目标函数接收右值]

错误处理与静态断言

在完美转发过程中，类型安全至关重要。MyTinySTL使用了静态断言来防止错误的转发：

template <class T>
T&& forward(typename std::remove_reference<T>::type&& arg) noexcept {
    static_assert(!std::is_lvalue_reference<T>::value, "bad forward");
    return static_cast<T&&>(arg);
}

这个静态断言确保不会将右值错误地转发为左值引用。

性能优势分析

可变参数模板与完美转发的组合带来了显著的性能优势：

技术 传统方法 现代方法 优势
参数传递 多次拷贝 完美转发 避免不必要的拷贝
构造方式 先构造后插入 原地构造 减少构造次数
类型安全 运行时检查 编译时检查 提前发现错误

实际应用示例

下面是一个完整的示例，展示如何在自定义容器中使用可变参数模板和完美转发：

template <class T>
class SimpleVector {
private:
    T* data_;
    size_t size_;
    size_t capacity_;
    
public:
    // 可变参数构造函数
    template <class... Args>
    void emplace_back(Args&&... args) {
        if (size_ >= capacity_) {
            resize();
        }
        // 使用完美转发在指定位置构造对象
        ::new (static_cast<void*>(data_ + size_)) 
            T(mystl::forward<Args>(args)...);
        ++size_;
    }
    
    // 其他成员函数...
};

编译时元编程结合

可变参数模板还可以与类型特征（type traits）和其他编译时技术结合使用：

// 检查所有参数是否满足某个条件
template <class... Args>
constexpr bool all_integral = (std::is_integral_v<Args> && ...);

// 使用SFINAE限制模板实例化
template <class... Args,
          typename = std::enable_if_t<(std::is_constructible_v<T, Args> && ...)>>
void construct_element(Args&&... args);

这种结合使用使得代码既灵活又类型安全，能够在编译期捕获大多数错误。

可变参数模板与完美转发是现代C++模板元编程的基石，它们为STL容器和算法提供了前所未有的灵活性和性能。通过深入理解这些技术的工作原理和应用场景，开发者可以编写出更加高效、安全和易于维护的C++代码。

移动语义与右值引用优化

在现代C++编程中，移动语义和右值引用是提升程序性能的关键技术。MyTinySTL作为一个小型STL实现，充分运用了C++11引入的这些特性来优化容器和算法的性能。本节将深入探讨MyTinySTL中移动语义的实现原理和应用场景。

右值引用的基础实现

MyTinySTL在util.h中实现了标准的move和forward函数，这是移动语义的基础：

template <class T>
typename std::remove_reference<T>::type&& move(T&& arg) noexcept
{
  return static_cast<typename std::remove_reference<T>::type&&>(arg);
}

template <class T>
T&& forward(typename std::remove_reference<T>::type& arg) noexcept
{
  return static_cast<T&&>(arg);
}

这两个函数通过类型转换实现了完美的转发和移动语义支持。move函数将参数转换为右值引用，而forward函数则根据模板参数类型保持值类别。

容器中的移动构造函数和移动赋值运算符

MyTinySTL中的所有容器都实现了移动构造函数和移动赋值运算符，以下以vector为例：

// 移动构造函数
vector(vector&& rhs) noexcept
  :begin_(rhs.begin_),
   end_(rhs.end_),
   cap_(rhs.cap_)
{
  rhs.begin_ = nullptr;
  rhs.end_ = nullptr;
  rhs.cap_ = nullptr;
}

// 移动赋值运算符
vector& operator=(vector&& rhs) noexcept
{
  destroy_and_recover(begin_, end_, cap_ - begin_);
  begin_ = rhs.begin_;
  end_ = rhs.end_;
  cap_ = rhs.cap_;
  rhs.begin_ = nullptr;
  rhs.end_ = nullptr;
  rhs.cap_ = nullptr;
  return *this;
}

这种实现方式通过简单的指针交换避免了深拷贝，大大提高了大对象转移的效率。移动操作后，源对象被置为有效但未定义的状态，符合C++标准的要求。

移动语义在算法中的应用

MyTinySTL在算法层面对移动语义进行了深度优化，特别是在algobase.h中实现的move和move_backward算法：

template <class InputIter, class OutputIter>
OutputIter move(InputIter first, InputIter last, OutputIter result)
{
  return unchecked_move(first, last, result);
}

// 针对不同迭代器类型的特化实现
template <class InputIter, class OutputIter>
OutputIter 
unchecked_move_cat(InputIter first, InputIter last, OutputIter result,
                   mystl::input_iterator_tag)
{
  for (; first != last; ++first, ++result)
  {
    *result = mystl::move(*first);  // 使用move而非copy
  }
  return result;
}

这些算法在处理可移动类型时能够显著提升性能，特别是在处理大型对象或资源密集型对象时。

完美转发在容器接口中的应用

MyTinySTL广泛使用完美转发来优化容器接口，如emplace系列函数：

template <class... Args>
void emplace_back(Args&& ...args)
{
  if (end_ < cap_)
  {
    data_allocator::construct(end_, mystl::forward<Args>(args)...);
    ++end_;
  }
  else
  {
    reallocate_emplace(end_, mystl::forward<Args>(args)...);
  }
}

void push_back(value_type&& value)
{ 
  emplace_back(mystl::move(value));  // 转发右值引用
}

通过完美转发，容器可以直接在目标位置构造对象，避免了临时对象的创建和拷贝。

类型特征与移动语义的协同

MyTinySTL利用类型特征来优化移动操作，特别是在内存操作方面：

template <class Tp, class Up>
typename std::enable_if<
  std::is_same<typename std::remove_const<Tp>::type, Up>::value &&
  std::is_trivially_move_assignable<Up>::value,
  Up*>::type
unchecked_move(Tp* first, Tp* last, Up* result)
{
  const size_t n = static_cast<size_t>(last - first);
  if (n != 0)
    std::memmove(result, first, n * sizeof(Up));  // 使用memmove优化
  return result + n;
}

对于平凡可移动的类型，直接使用memmove进行内存拷贝，这是最高效的移动方式。

异常安全保证

MyTinySTL为移动操作提供了强异常安全保证。移动构造函数和移动赋值运算符都被标记为noexcept，这确保了在移动操作过程中不会抛出异常：

vector(vector&& rhs) noexcept;  // 不会抛出异常
vector& operator=(vector&& rhs) noexcept;  // 不会抛出异常

这种设计使得容器可以在异常安全的环境中安全使用，同时也为标准库算法提供了优化机会。

实际应用示例

以下代码展示了MyTinySTL中移动语义的实际应用：

// 创建临时vector并移动
mystl::vector<int> create_vector() {
    mystl::vector<int> temp{1, 2, 3, 4, 5};
    return temp;  // 触发移动语义
}

void use_vector() {
    mystl::vector<int> v1{1, 2, 3};
    mystl::vector<int> v2 = std::move(v1);  // 显式移动
    
    // 使用emplace避免拷贝
    v2.emplace_back(4);  // 直接在容器内构造
    v2.push_back(5);     // 需要拷贝或移动
}

性能优化效果

移动语义的引入带来了显著的性能提升：

操作类型 拷贝语义 移动语义 性能提升
容器转移 O(n)拷贝 O(1)指针交换 显著
算法操作 多次拷贝 一次移动 中等
资源管理 深拷贝 浅拷贝 显著

通过移动语义，MyTinySTL在处理大型数据结构和资源密集型对象时能够实现接近原生指针操作的性能，同时保持类型安全和异常安全。

最佳实践建议

  1. 优先使用emplace：在可能的情况下使用emplace系列函数，避免不必要的拷贝或移动
  2. 明确移动意图：使用std::move明确表示不再使用源对象
  3. 利用返回值优化：函数返回局部对象时会自动应用移动语义
  4. 注意对象状态：移动后的对象处于有效但未定义状态，不应再使用

MyTinySTL通过全面实现移动语义和右值引用优化，展示了现代C++在性能优化方面的强大能力。这些技术不仅提升了库本身的性能，也为使用者提供了编写高效代码的最佳实践范例。

MyTinySTL通过系统化应用现代C++模板元编程技术，展示了如何构建高效、类型安全的STL实现。SFINAE与enable_if提供了精确的类型约束和重载选择机制，type_traits实现了编译时类型特性萃取，可变参数模板与完美转发支持了灵活的接口设计，而移动语义与右值引用则大幅提升了资源管理效率。这些技术的有机结合不仅优化了性能，还增强了代码的泛用性和安全性，为C++开发者提供了宝贵的模板元编程实践范例。

MyTinySTL
Achieve a tiny STL in C++11
项目地址：https://gitcode.com/gh_mirrors/my/MyTinySTL
登录后查看全文

相关内容推荐

1 MyTinySTL：C++11微型STL实现深度解析2 探索VISIO集成电路设计的新境界：元器件模板与操作指南3 C++模板元编程4 攻克C++模板技术壁垒：从入门到精通的Cpp-Templates-2ed实践指南5 完整掌握PPTist：免费在线PPT制作工具深度使用指南6 【免费下载】 VISIO集成电路元器件模板和操作7 cppformat项目中模板类内枚举类型的格式化问题解析8 开源项目推荐：MP - 现代元编程的未来之路9 探索强大的TypeScript模板库：Typed HTML10 PPTist：可视化在线PPT制作与幻灯片编辑器
热门项目推荐
相关项目推荐

热门内容推荐

1 【亲测免费】 开源项目 `build-your-own-x` 使用指南2 【亲测免费】 探索科技之旅：《Build Your Own X》项目详解3 GitHub_Trending/bu/build-your-own-x自动化：CI/CD流程在自制项目中的应用4 从零打造智能家居系统：用build-your-own-x实现家庭自动化

最新内容推荐

Degrees of Lewdity中文汉化终极指南：零基础玩家必看的完整教程Unity游戏翻译神器：XUnity Auto Translator 完整使用指南PythonWin7终极指南：在Windows 7上轻松安装Python 3.9+终极macOS键盘定制指南：用Karabiner-Elements提升10倍效率Pandas数据分析实战指南：从零基础到数据处理高手 Qwen3-235B-FP8震撼升级：256K上下文+22B激活参数7步搞定机械键盘PCB设计：从零开始打造你的专属键盘终极WeMod专业版解锁指南：3步免费获取完整高级功能DeepSeek-R1-Distill-Qwen-32B技术揭秘：小模型如何实现大模型性能突破音频修复终极指南：让每一段受损声音重获新生

项目优选

收起
kernelkernel
deepin linux kernel
C
27
11
docsdocs
OpenHarmony documentation | OpenHarmony开发者文档
Dockerfile
532
3.75 K
nop-entropynop-entropy
Nop Platform 2.0是基于可逆计算理论实现的采用面向语言编程范式的新一代低代码开发平台，包含基于全新原理从零开始研发的GraphQL引擎、ORM引擎、工作流引擎、报表引擎、规则引擎、批处理引引擎等完整设计。nop-entropy是它的后端部分，采用java语言实现，可选择集成Spring框架或者Quarkus框架。中小企业可以免费商用
Java
12
1
leetcodeleetcode
🔥LeetCode solutions in any programming language | 多种编程语言实现 LeetCode、《剑指 Offer（第 2 版）》、《程序员面试金典（第 6 版）》题解
Java
67
20
flutter_flutterflutter_flutter
暂无简介
Dart
772
191
pytorchpytorch
Ascend Extension for PyTorch
Python
340
405
ops-mathops-math
本项目是CANN提供的数学类基础计算算子库，实现网络在NPU上加速计算。
C++
886
596
giteagitea
喝着茶写代码！最易用的自托管一站式代码托管平台，包含Git托管，代码审查，团队协作，软件包和CI/CD。
Go
23
0
ohos_react_nativeohos_react_native
React Native鸿蒙化仓库
JavaScript
303
355
kernelkernel
openEuler内核是openEuler操作系统的核心，既是系统性能与稳定性的基石，也是连接处理器、设备与服务的桥梁。
C
336
178