multiarray.h File Reference

提供编译期维度固定的多维数组容器 MultiArray，支持任意维度和元素级算术/逻辑/位运算。 More...

#include <algorithm>
#include <array>
#include <cstddef>
#include <cstring>
#include <initializer_list>
#include <iostream>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include "../core/csexc.h"
#include "../text/repr.h"

Go to the source code of this file.

Classes
class	console::_V1::MultiArray< T, D >
	一维特化。 More...
class	console::_V1::MultiArray< T, First, Rest... >
	多维特化(维度 >= 2)。 More...
struct	console::_V2::_multi_array_base< T >
	编译期固定维度的多维数组元数据。 More...
class	console::_V2::MultiArray< T, D >
	一维特化。 More...
class	console::_V2::MultiArray< T, First, Rest... >
	多维特化(维度 >= 2)。 More...
struct	console::_V2::MultiArray< T, First, Rest... >::prod< I >
struct	console::_V2::MultiArray< T, First, Rest... >::prod< I, Is... >
class	console::_V2::MultiArray< T, First, Rest... >::iterator
	随机访问迭代器，遍历第一维的子数组。 More...
class	console::_V2::MultiArray< T, First, Rest... >::const_iterator
	const 随机访问迭代器。 More...

Namespaces
namespace	console
	本库所有组件所在的顶层命名空间。
namespace	console::_V1
namespace	console::_V2

Macros
#define	ARRAY_AND_ARRAY(OP)
#define	ARRAY_AND_SCALAR(OP)
#define	SCALAR_AND_ARRAY(OP)
#define	ARRAY_AND_ARRAY_INPLACE(OP)
#define	ARRAY_AND_SCALAR_INPLACE(OP)
#define	ARRAY_AND_ARRAY_BOOL(OP)
#define	ARRAY_AND_SCALAR_BOOL(OP)
#define	SCALAR_AND_ARRAY_BOOL(OP)
#define	UNARY_ARRAY(OP)
#define	UNARY_ARRAY_BOOL(OP)

Functions
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()+std::declval< U >()), Dims... >	console::operator+ (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() - std::declval< U >()), Dims... >	console::operator- (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() *std::declval< U >()), Dims... >	console::operator* (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()/std::declval< U >()), Dims... >	console::operator/ (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() % std::declval< U >()), Dims... >	console::operator% (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator+= (MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator-= (MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator*= (MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator/= (MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator%= (MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator+= (MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator-= (MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator*= (MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator/= (MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator%= (MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator== (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator!= (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator< (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator> (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator<= (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator>= (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()+std::declval< U >()), Dims... >	console::operator+ (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() - std::declval< U >()), Dims... >	console::operator- (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() *std::declval< U >()), Dims... >	console::operator* (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()/std::declval< U >()), Dims... >	console::operator/ (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() % std::declval< U >()), Dims... >	console::operator% (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()+std::declval< U >()), Dims... >	console::operator+ (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() - std::declval< U >()), Dims... >	console::operator- (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() *std::declval< U >()), Dims... >	console::operator* (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()/std::declval< U >()), Dims... >	console::operator/ (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() % std::declval< U >()), Dims... >	console::operator% (const U &a, const MultiArray< T, Dims... > &b)
template<class T, size_t... Dims>
MultiArray< decltype(+std::declval< T >()), Dims... >	console::operator+ (const MultiArray< T, Dims... > &a)
template<class T, size_t... Dims>
MultiArray< decltype(- std::declval< T >()), Dims... >	console::operator- (const MultiArray< T, Dims... > &a)
template<class T, size_t... Dims>
MultiArray< decltype(~ std::declval< T >()), Dims... >	console::operator~ (const MultiArray< T, Dims... > &a)
template<class T, size_t... Dims>
MultiArray< bool, Dims... >	console::operator! (const MultiArray< T, Dims... > &a)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator== (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator!= (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator< (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator> (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator<= (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator>= (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator== (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator!= (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator< (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator> (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator<= (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator>= (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator&& (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator|| (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator&& (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator|| (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator&& (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< bool, Dims... >	console::operator|| (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() &std::declval< U >()), Dims... >	console::operator& (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()|std::declval< U >()), Dims... >	console::operator| (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() ^ std::declval< U >()), Dims... >	console::operator^ (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()<< std::declval< U >()), Dims... >	console::operator<< (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() > > std::declval< U >()), Dims... >	console::operator>> (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator&= (MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator|= (MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator^= (MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator<<= (MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator>>= (MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() &std::declval< U >()), Dims... >	console::operator& (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()|std::declval< U >()), Dims... >	console::operator| (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() ^ std::declval< U >()), Dims... >	console::operator^ (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()<< std::declval< U >()), Dims... >	console::operator<< (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() > > std::declval< U >()), Dims... >	console::operator>> (const MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() &std::declval< U >()), Dims... >	console::operator& (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >()|std::declval< U >()), Dims... >	console::operator| (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() ^ std::declval< U >()), Dims... >	console::operator^ (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
MultiArray< decltype(std::declval< T >() > > std::declval< U >()), Dims... >	console::operator>> (const U &a, const MultiArray< T, Dims... > &b)
template<class T, class U, size_t... Dims>
std::enable_if<!std::is_base_of< std::ios_base, U >::value, MultiArray< decltype(std::declval< U >()<< std::declval< T >()), Dims... > >::type	console::operator<< (const U &value, const MultiArray< T, Dims... > &a)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator&= (MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator|= (MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator^= (MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator<<= (MultiArray< T, Dims... > &a, const U &b)
template<class T, class U, size_t... Dims>
MultiArray< T, Dims... > &	console::operator>>= (MultiArray< T, Dims... > &a, const U &b)
template<class T, size_t... Dims>
T	console::sum (const MultiArray< T, Dims... > &a)
	求和所有元素。
template<class T, size_t... Dims>
T	console::min (const MultiArray< T, Dims... > &a)
	求最小值。
template<class T, size_t... Dims>
T	console::max (const MultiArray< T, Dims... > &a)
	求最大值。
template<class T, size_t... Dims>
bool	console::all (const MultiArray< T, Dims... > &a)
	检查所有元素是否都为 true(逻辑与归约)。
template<class T, size_t... Dims>
bool	console::any (const MultiArray< T, Dims... > &a)
	检查是否存在至少一个 true 元素(逻辑或归约)。
template<class T, class U, size_t... Dims>
bool	console::equals (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
	检查两个 MultiArray 是否相等。
template<class T, class U, size_t... Dims1, size_t... Dims2>
constexpr bool	console::equals (const MultiArray< T, Dims1... > &, const MultiArray< U, Dims2... > &)
	检查两个 MultiArray 是否相等。
template<class T, class U, size_t... Dims, class Op>
bool	console::equals (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b, Op &&op)
	检查两个 MultiArray 是否相等。
template<class T, class U, size_t... Dims1, size_t... Dims2, class Op>
constexpr bool	console::equals (const MultiArray< T, Dims1... > &, const MultiArray< U, Dims2... > &, Op &&)
	检查两个 MultiArray 是否相等。
template<class T, class U, size_t... Dims>
int	console::compare (const MultiArray< T, Dims... > &a, const MultiArray< U, Dims... > &b)
	比较两个 MultiArray 的大小。

Detailed Description

提供编译期维度固定的多维数组容器 MultiArray，支持任意维度和元素级算术/逻辑/位运算。

MultiArray 使用堆内存存储，支持视图语义、 扁平化迭代器 fbegin/fend、元素级运算(包括数组与数组、数组与标量)、 统计函数(sum/min/max/all/any)等。

Author

MrXie1109

Date

2026

Copyright

MIT License

Macro Definition Documentation

ARRAY_AND_ARRAY

#define ARRAY_AND_ARRAY

(

OP

)

Value:

template <class T, class U, size_t... Dims>                                \
MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>      \
operator OP(const MultiArray<T, Dims...> &a,                               \
            const MultiArray<U, Dims...> &b) {                             \
    MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>  \
        c;                                                                 \
    auto ai = a.fbegin();                                                  \
    auto bi = b.fbegin();                                                  \
    auto ci = c.fbegin();                                                  \
    while (ci != c.fend()) *ci++ = *ai++ OP *bi++;                         \
    return c;                                                              \
}

ARRAY_AND_ARRAY_BOOL

#define ARRAY_AND_ARRAY_BOOL

(

OP

)

Value:

template <class T, class U, size_t... Dims>                                \
MultiArray<bool, Dims...>                                                  \
operator OP(const MultiArray<T, Dims...> &a,                               \
            const MultiArray<U, Dims...> &b) {                             \
    MultiArray<bool, Dims...> c;                                           \
    auto ai = a.fbegin();                                                  \
    auto bi = b.fbegin();                                                  \
    auto ci = c.fbegin();                                                  \
    while (ci != c.fend()) *ci++ = *ai++ OP *bi++;                         \
    return c;                                                              \
}

ARRAY_AND_ARRAY_INPLACE

#define ARRAY_AND_ARRAY_INPLACE

(

OP

)

Value:

template <class T, class U, size_t... Dims>                                \
MultiArray<T, Dims...> & operator OP(                                      \
        MultiArray<T, Dims...> &a,                                         \
        const MultiArray<U, Dims...> &b) {                                 \
    auto ai = a.fbegin();                                                  \
    auto bi = b.fbegin();                                                  \
    while (ai != a.fend()) *ai++ OP *bi++;                                 \
    return a;\
}

ARRAY_AND_SCALAR

#define ARRAY_AND_SCALAR

(

OP

)

Value:

template <class T, class U, size_t... Dims>                                \
MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>      \
operator OP(const MultiArray<T, Dims...> &a, const U &b) {                 \
    MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>  \
        c;                                                                 \
    auto ai = a.fbegin();                                                  \
    auto ci = c.fbegin();                                                  \
    while (ci != c.fend()) *ci++ = *ai++ OP b;                             \
    return c;                                                              \
}

ARRAY_AND_SCALAR_BOOL

#define ARRAY_AND_SCALAR_BOOL

(

OP

)

Value:

template <class T, class U, size_t... Dims>                                \
MultiArray<bool, Dims...>                                                  \
operator OP(const MultiArray<T, Dims...> &a, const U &b) {                 \
    MultiArray<bool, Dims...> c;                                           \
    auto ai = a.fbegin();                                                  \
    auto ci = c.fbegin();                                                  \
    while (ci != c.fend()) *ci++ = *ai++ OP b;                             \
    return c;                                                              \
}

ARRAY_AND_SCALAR_INPLACE

#define ARRAY_AND_SCALAR_INPLACE

(

OP

)

Value:

template <class T, class U, size_t... Dims>                                \
MultiArray<T, Dims...> & operator OP(MultiArray<T, Dims...> &a,            \
                                     const U &b) {                         \
    auto ai = a.fbegin();                                                  \
    while (ai != a.fend()) *ai++ OP b;                                     \
    return a;                                                              \
}

SCALAR_AND_ARRAY

#define SCALAR_AND_ARRAY

(

OP

)

Value:

template <class T, class U, size_t... Dims>                                \
MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>      \
operator OP(const U &a, const MultiArray<T, Dims...> &b) {                 \
    MultiArray<decltype(std::declval<T>() OP std::declval<U>()), Dims...>  \
        c;                                                                 \
    auto bi = b.fbegin();                                                  \
    auto ci = c.fbegin();                                                  \
    while (ci != c.fend()) *ci++ = a OP *bi++;                             \
    return c;                                                              \
}

SCALAR_AND_ARRAY_BOOL

#define SCALAR_AND_ARRAY_BOOL

(

OP

)

Value:

template <class T, class U, size_t... Dims>                                \
MultiArray<bool, Dims...>                                                  \
operator OP(const U &a, const MultiArray<T, Dims...> &b) {                 \
    MultiArray<bool, Dims...> c;                                           \
    auto bi = b.fbegin();                                                  \
    auto ci = c.fbegin();                                                  \
    while (ci != c.fend()) *ci++ = a OP *bi++;                             \
    return c;                                                              \
}

UNARY_ARRAY

#define UNARY_ARRAY

(

OP

)

Value:

template <class T, size_t... Dims>                                         \
MultiArray<decltype(OP std::declval<T>()), Dims...>                        \
operator OP(const MultiArray<T, Dims...> &a) {                             \
    MultiArray<decltype(OP std::declval<T>()), Dims...> c;                 \
    auto ai = a.fbegin();                                                  \
    auto ci = c.fbegin();                                                  \
    while (ci != c.fend()) *ci++ = OP *ai++;                               \
    return c;                                                              \
}

UNARY_ARRAY_BOOL

#define UNARY_ARRAY_BOOL

(

OP

)

Value:

template <class T, size_t... Dims>                                         \
MultiArray<bool, Dims...>                                                  \
operator OP(const MultiArray<T, Dims...> &a) {                             \
    MultiArray<bool, Dims...> c;                                           \
    auto ai = a.fbegin();                                                  \
    auto ci = c.fbegin();                                                  \
    while (ci != c.fend()) *ci++ = OP *ai++;                               \
    return c;                                                              \
}