如何使用my_vector类创建my_matrix？我创建了一个具有标量积，加法，点积功能等的vector类。现在我想创建一个使用vector作为列的矩阵类。

my_vector.h

#pragma once
#include <cassert>
#include <cmath>
#include <cstddef>
#include <initializer_list>
#include <stdexcept>
using namespace std;
inline auto& lengtherr = "Not compatible";
template <typename T>
class my_vector
{
private :
    size_t m_dim;
    T *m_arr;
public:
    my_vector(size_t s = 0) : m_dim{s}, m_arr{new T[s]} {}
    my_vector(const my_vector &rhs) : m_dim{rhs.m_dim},m_arr{new T [rhs.m_dim]}
    {
        for(int i = 0  ; i<rhs.m_dim;++i)m_arr[i] = rhs.m_arr[i];
    }
    my_vector(initializer_list<T> list): my_vector(list.size())
    {
        m_dim = list.size();
        int cnt = 0;
        for(auto i : list)
        m_arr[cnt++] = i;
    }
    ~my_vector() { delete[] m_arr; }
    size_t dim() const { return m_dim; }
    void operator=(const my_vector<T> &v)
    { 
        if(v.dim()== m_dim)
        {
            for(int i = 0 ; i < m_dim;++i)
            m_arr[i] = v[i];
        }
        else
        throw length_error(lengtherr);
    }
    T &operator[](size_t idx)
    {
        assert(idx<m_dim);
        return m_arr[idx];
    }
    const T& operator[](size_t idx)const
    {
        assert(idx<m_dim);
        return m_arr[idx];
    }
    T length()
    {
        T temp;temp = m_arr[0]*m_arr[0];
        for(int i = 1 ; i< m_dim;++i)temp+= m_arr[i]*m_arr[i];
        return sqrt(temp);
    }
    void normalize()
    {
        T len = 1/(this->length());
        *this = *this * len;
    }
};

字符串
这是my_matrix类

my_matrix. h

template<typename T>
class my_matrix
{
   
    size_t m_row{0};
    size_t m_col{0};
    public : my_vector<T> *m_mat;
    my_matrix(size_t r, size_t c) : m_row{r},m_col{c}
    {
        /*How do I construct??*/
    }
    ~my_matrix()
    {
        /*destructor*/     
    }
};

型
我试图做的是创建my_matrix，并将my_vectors作为列，但如何在动态分配内存给my_matrix时控制my_vector长度？

public : my_vector<my_vector<T>> m_mat;
my_matrix(size_t r, size_t c) :
m_row{r},
m_col{c},
m_mat(m_col) // you have m_col number of columns
{
for( size_t i = 0; i < m_col; ++i )
m_mat[i] = my_vector<T>(m_row); // the columns are m_row long
}

template<class T>
struct my_vector_view {
T* m_data = nullptr;
std::size_t length = 0u;
my_vector_view(T* s, T* e):my_vector_view(s, e-s) {}
my_vector_view(T* s, std::size_t l):m_data(s), length(l) {}
my_vector_view() {}
T& operator[](std::size_t i)& { return m_data[i]; }
T const& operator[](std::size_t i) const& { return m_data[i]; }
T operator[](std::size_t i) && { return std::move(m_data[i]); }
// etc
};

template<class T>
struct matrix {
std::size_t m_row = 0;
std::size_t m_col = 0;
std::vector<T> m_data;
my_vector_view<T> operator[](std::size_t i)& {
return { m_data.data()+i*m_row, m_row };
}
// etc
};

1条答案

按热度按时间

fkvaft9z1#

我要做的第一件事是：

my_vector<my_vector<T>> m_mat;

字符串
使用vector类来存储vector的vector。
一般的规则是，你不想管理所有的资源，你想在专门管理资源的类中管理资源，其他类使用它们。
也就是说，你的matrix类应该使用 some other class 来管理它的内存使用。
这个矩阵是向量的向量可以工作，但它会导致记忆碎片。
因此，第二次迭代将涉及编写一个vector_view，它 Package 了一块连续内存，但不拥有它。

std::vector<T> m_mat_data;

型
列的大小是该数据块的vector_view s。
使用向量视图与之交互的连续缓冲区提供了很好的性能，因为您避免了多次分配，获得了连续内存，并在执行中间工作时避免了不必要的分配。
当然，让它工作得很好需要一点技巧，你的my_vector甚至没有const长度方法，这证明你缺乏足够的C++经验来使它变得容易。
向量的向量解决方案在你的技能水平上更容易使用，并且应该给你给予足够好的体验。在编写这个的contiguous-with-views变体时，我经常会编写更简单的容器的容器版本来验证我更有效和复杂的版本。
所以写vector的vector版本就开始了。

public : my_vector<my_vector<T>> m_mat;
my_matrix(size_t r, size_t c) :
  m_row{r},
  m_col{c},
  m_mat(m_col) // you have m_col number of columns
{
  for( size_t i = 0; i < m_col; ++i )
    m_mat[i] = my_vector<T>(m_row); // the columns are m_row long
}

型
现在，std::vector<T>有一个双参数构造函数size, T，如果你把它添加到my_vector，你会得到一个稍微干净的解决方案：

public : my_vector<my_vector<T>> m_mat;
my_matrix(size_t r, size_t c) :
  m_row{r},
  m_col{c},
  m_mat(m_col, my_vector<T>(m_row))
{
}

型
对于视图情况：

template<class T>
struct my_vector_view {
  T* m_data = nullptr;
  std::size_t length = 0u;
  my_vector_view(T* s, T* e):my_vector_view(s, e-s) {}
  my_vector_view(T* s, std::size_t l):m_data(s), length(l) {}
  my_vector_view() {}
  T& operator[](std::size_t i)& { return m_data[i]; }
  T const& operator[](std::size_t i) const& { return m_data[i]; }
  T operator[](std::size_t i) && { return std::move(m_data[i]); }
  // etc
};

型
然后

template<class T>
struct matrix {
  std::size_t m_row = 0;
  std::size_t m_col = 0;
  std::vector<T> m_data;
  my_vector_view<T> operator[](std::size_t i)& {
    return { m_data.data()+i*m_row, m_row };
  }
  // etc
};

型
这里matrix[i]返回列向量的视图，matrix[i][j]返回矩阵的单个元素。
我们甚至可以用class stride=std::integral_constant<std::size_t, 1>来扩充vector_view，并且也有行向量支持。

展开查看全部

赞(0）回复(0）举报 2024-01-09

在C++中创建一个用户定义的向量数组来创建一个用户定义的矩阵

my_vector.h

my_matrix. h

1条答案

相关问题

热门标签

最新问答