好吧，我已经在谷歌上搜索了太久，我只是不确定如何称呼这种技术，所以我认为最好在这里问一下。如果我忽略了明显的名称和/或解决方案，请指出正确的方向。

对于外行来说:张量是矩阵的逻辑扩展，就像矩阵是 vector 的逻辑扩展一样。 vector 是 1 阶张量(在编程术语中，一维数字数组)，矩阵是 2 阶张量(2 维数字数组)，N 阶张量只是一个 N 维数字数组.

现在，假设我有类似这个 Tensor 类的东西:

template<typename T = double> // possibly also with size parameters
class Tensor
{
  private: 
    T *M;  // Tensor data (C-array)
           // alternatively, std::vector<T> *M 
           // or std::array<T> *M 
           // etc., or possibly their constant-sized versions
           // using Tensor<>'s template parameters

  public: 

    ... // insert trivial fluffy stuff here 

    // read elements
    const T & operator() (size_t a, size_t b) const {
        ... // error checks etc.
        return M[a + rows*b];
    }

    // write elements
    T & operator() (size_t a, size_t b) {
        ... // error checks etc.
        return M[a + rows*b];
    }

    ... 

};

使用这些定义 operator()(...) ，索引/分配单个元素然后具有相同的调用签名:

Tensor<> B(5,5);
double a = B(3,4);   // operator() (size_t,size_t) used to both GET elements
B(3,4) = 5.5;        // and SET elements

将其扩展到任意张量等级是相当微不足道的。但我希望能够实现的是一种更高级的索引/分配元素的方法:

Tensor<> B(5,5);
Tensor<> C = B( Slice(0,4,2), 2 );  // operator() (Slice(),size_t) used to GET elements
B( Slice(0,4,2), 2 ) = C;           // and SET elements 
         // (C is another tensor of the correct dimensions)

我知道 std::valarray (以及许多其他与此相关的事情)已经做了非常相似的事情，但我的目标不是仅仅完成行为；我的目标是学习如何优雅地、高效地和安全地将以下功能添加到我的 Tensor<>类:

// Indexing/assigning with Tensor<bool>
B( B>0 ) += 1.0;   

// Indexing/assigning arbitrary amount of dimensions, each dimension indexed 
// with either Tensor<bool>, size_t, Tensor<size_t>, or Slice()
B( Slice(0,2,FINAL), 3, Slice(0,3,FINAL), 4 ) = C; 

// double indexing/assignment operation
B(3, Slice(0,4,FINAL))(mask) = C;  // [mask] == Tensor<bool>

.. etc.

请注意，我打算使用 operator[]对于 operator() 的非检查版本.或者，我会更多地关注 std::vector<>使用方法 .at() operator[] 检查版本的方法.无论如何，这是一个设计选择，除了现在的问题。

我想到了以下不完整的“解决方案”。这种方法仅适用于 vector/矩阵(rank-1 或 rank-2 张量)，并且有许多不良副作用:

// define a simple slice class
Slice () 
{ 
  private:
    size_t 
        start, stride, end; 

  public: 
    Slice(size_t s, size_t e) : start(s), stride(1), end(e) {}
    Slice(size_t s, size_t S, size_t e) : start(s), stride(S), end(e) {}
    ...

};

template<typename T = double>
class Tensor
{
    ... // same as before

  public:       

    // define two operators() for use with slices:     

    // version for retrieving data
    const Tensor<T> & operator() (Slice r, size_t c) const {
        // use slicing logic to construct return tensor
        ...
        return M;
    {

    // version for assigning data
    Sass operator() (Slice r, size_t c) {
        // returns Sass object, defined below
        return Sass(*this, r,c);
    }

  protected:

    class Sass 
    {
        friend class Tensor<T>;

     private:        
        Tensor<T>& M;
        const Slice &R;
        const size_t c;

      public:

        Sass(Tensor<T> &M, const Slice &R, const size_t c)
            : M(M)
            , R(R)
            , c(c)
        {}

        operator Tensor<T>() const { return M; }

        Tensor<T> & operator= (const Tensor<T> &M2) {
            // use R/c to copy contents of M2 into M using the same 
            // Slice-logic as in "Tensor<T>::operator()(...) const" above
            ...

            return M;
        }

    };  

但这只是感觉不对...

对于上面列出的每个索引/分配方法，我必须定义一个单独的 Tensor<T>::Sass::Sass(...)构造函数，一个新的 Tensor<T>::Sass::operator=(...) , 和一个新的 Tensor<T>::operator()(...)对于每一个这样的操作。此外，Tensor<T>::Sass::operators=(...)将需要包含许多与相应 Tensor<T>::operator()(...) 中已有的相同内容，并使一切都适合 Tensor<> 任意排名 使得这种方法非常丑陋，过于冗长，更重要的是，完全无法管理。

所以，我觉得有一种更有效的方法可以解决所有这些问题。

有什么建议吗？

最佳答案

首先我想指出一些设计问题:

T & operator() (size_t a, size_t b) const; 

建议您不能通过此方法更改矩阵，因为它是const。但是您返回的是对矩阵元素的非常量引用，所以实际上您可以更改它。这只会因为您使用的原始指针而编译。我建议改用 std::vector，它会为您进行内存管理，但会给您一个错误，因为 vector 的 operator[] const 版本提供了一个 const 引用，例如它应该。

关于您的实际问题，我不确定 Slice 构造函数的参数应该做什么，也不确定 Sass 对象的含义(我不是母语人士，“Sass”在字典中只给我一个翻译, 意思是“无礼”、“无礼”)。 但是，我假设您希望使用切片创建一个对象，该对象可以访问由切片参数定义的矩阵子集。

我建议不要对访问矩阵的所有方法都使用 operator()。 op() 使用两个索引来访问给定元素似乎很自然。使用类似的运算符来获得整个矩阵对我来说似乎不太直观。

这里有一个想法:制作一个 Slice 类，该类包含对 Matrix 的引用以及定义 Slice 表示 Matrix 的哪一部分的必要参数。这样，一个 Slice 就像它定义的 Matrix 子集的代理，类似于一对迭代器，可以看作是它们所指向的容器的子范围的代理。给您的 Matrix 一对 slice() 方法(const 和 nonconst)返回一个 Slice/ConstSlice，引用您调用该方法的 Matrix。这样，您甚至可以检查该方法以查看 Slice 的参数对于它所引用的 Matrix 是否有意义。如果有意义且有必要，您还可以添加一个转换运算符，将 Slice 转换为它自己的 Matrix。

一次又一次地重载 operator() 并将参数用作掩码，因为线性索引和其他东西比帮助 imo 更令人困惑。如果 operator() 做的事情自然而然，符合所有人的期望，那么它就是精巧的。如果在任何地方都使用它，它只会混淆代码。请改用命名方法。

关于c++ - 如何使用相同的调用签名在张量中索引和分配元素？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/13679195/