如何自动生成 C++ 函数？

Question

我想写一个c++矩阵运算代码，某些函数的某些操作是一样的。我想知道是否有一些方法可以合并它们？例如：

void add1(vector<vector<double> > &m){
    for(int i = 0; i < m.size(); ++i){
        for(int j = 0; j < m[i].size(); ++j){
            m[i][j] += 1.0;
        }
    }
}

void minus1(vector<vector<double> > &m){
    for(int i = 0; i < m.size(); ++i){
        for(int j = 0; j < m[i].size(); ++j){
            m[i][j] -= 1.0;
        }
    }
}

这两段代码几乎是一样的。如何避免重写两次？有没有模板之类的东西可以自动生成代码？

Answer 1

您可以定义一个函数模板并将迭代元素的核心逻辑放在该函数中。

模板参数可以是函子，可用于定义每个特定调用会发生什么。

// Change m to be a reference so the modifications to the elements
// are visible in the calling function.

template <typename Functor>
void for_each_member(vector<vector<double> >& m, Functor functor)
{
   for(std::size_t i = 0; i < m.size(); ++i){
      for(std::size_t j = 0; j < m[i].size(); ++j){
         functor(m[i][j]);
      }
   }
}

void add1(vector<vector<double> >& m){
   for_each_member(m, [](double& item) { item += 1.0;});
}

void minus1(vector<vector<double> >& m){
   for_each_member(m, [](double& item) { item -= 1.0;});
}

Answer 2

您可以通过以下方式进行概括：

template<typename T, typename F>
void for_each_element(std::vector<std::vector<T>> &m, F &&f) {
  std::for_each(m.begin(), m.end(), [f] (auto &&v) {
    std::transform(v.begin(), v.end(), v.begin(), f);
  });
}

Live Demo

但是，请注意，将矩阵表示为 std::vector<std::vector<T>> 对缓存不是很友好，因为您将矩阵的行分散到整个内存中。如果您有一个自定义矩阵类，它会在内部使用一个 std::vector 并重载 row/column major 访问的下标运算符，那就更好了。

Answer 3

您可以使用第二个参数创建一个 func，然后将其添加到矩阵的每个成员中。

Answer 4

你可以这样定义

template <template <class> class pred>
void apply(vector<vector<double>> & m) {
    for (auto & i : m)
        for (auto & j : i)
            j = pred<double>()(j, 1.0);
}

如需添加，请致电

apply<std::plus>(m);

同样，减法

apply<std::minus>(m);

你也可以使用<functional>中的其他函数对象

查看工作中的DEMO。

Answer 5

您还可以为您的矩阵编写一个迭代器。这并不完整，但给了你一个想法：

#include <vector>
#include <algorithm>

template< class _T >
class Matrix
{
public:
    std::vector< std::vector< _T > > m_matrix;
    void alloc( size_t rows, size_t cols )
    {
        m_matrix.resize( rows );
        std::for_each( m_matrix.begin(), m_matrix.end(), [cols](std::vector<_T> &t){t.resize(cols);});
    }
    class iterator
    {
    public:
        iterator( std::vector< std::vector< _T > > & v ):
            m_vbegin( v.begin() ),
            m_vi( v.begin() ),
            m_i( m_vi->begin() ),
            m_vend( v.end() )
        {}
        iterator& operator++()
        {
            if ( ++m_i == m_vi->end() )
            {
                if ( ++m_vi != m_vend )
                    m_i = m_vi->begin();
            }
            return (*this);
        }
        void gotobegin()
        {
            m_vi=m_vbegin;
            m_i=m_vi->begin();
        }
        void gotoend()
        {
            m_vi=m_vend;
        }
        _T & operator*()
        {
            return *m_i;
        }
        bool operator==(const iterator & rhs )
        {
            if ( m_vi==rhs.m_vi && (m_vi==m_vend || m_i==rhs.m_i) )
                return true;
            return false;
        }
        bool operator!=(const iterator & rhs )
        {
            return !( *this == rhs );
        }
    private:
        typename std::vector< std::vector< _T > >::iterator m_vi;
        const typename std::vector< std::vector< _T > >::iterator m_vbegin;
        const typename std::vector< std::vector< _T > >::iterator m_vend;
        typename std::vector< _T >::iterator m_i;
    };
    iterator begin(){ return iterator(m_matrix); }
    iterator end(){ iterator ret(m_matrix); ret.gotoend(); return ret;}
};
int main( void )
{
    Matrix<double> matrix;
    matrix.alloc( 4000, 4000 );
    std::for_each( matrix.begin(), matrix.end(), []( double &t){ t=1.0;} );
    std::for_each( matrix.begin(), matrix.end(), []( double &t){ t+=1.0;} );
    return 0;
}

Answer 6

除了其他答案。您也可以使用std::function（请参阅http://en.cppreference.com/w/cpp/utility/functional/function）。在这里，您必须定义返回类型以及参数类型。使用它，您可以传递任何可调用的内容。

这是一个例子：

#include <iostream>
#include <functional>
#include <vector>

using matrix = std::vector<std::vector<double>>;

void for_each_member(matrix& m, std::function<void(double&)> functor)
{
  for (auto &vec : m)
    for (auto &element : vec)
      functor(element);
}

static void sub(double &ele)
{
  --ele;
}

int main()
{
  matrix m = { {1,2}, {3,4} };

  for_each_member(m, [](auto &ele) { ++ele; });
  for_each_member(m, [](auto &ele) {std::cout << ele << " "; });

  std::cout << "\n";

  for_each_member(m, sub);
  for_each_member(m, [](auto &ele) {std::cout << ele << " "; });
  std::cout << "\n";

  return 0;
}

Answer 7

免责声明：我打破了 vector 提供的一些 C++ 封装，以显示一个可能更快的解决方案，可以提供你想要的。一些在 SO 上使用 C++ 标签的纯粹主义者肯定会因为我向您展示一些 ahem C 代码而敲门。但无论如何我都会给你看。你可以自己做决定。

inline void add_to_every_element(vector<double>* rows, size_t m_size, double d)
{
    for (size_t i = 0; i < m_size; i++)
    {
        size_t row_size = rows[i].size();
        double* row = rows[i].data();
        for (size_t j = 0; j < row_size; j++)
        {
            row[j] += d;
        }
    }
}

void add1(vector<vector<double> > &m)
{
    add_to_every_element(m.data(), m.size(), 1.0);
}

void minus1(vector<vector<double>>& m)
{
    add_to_every_element(m.data(), m.size(), -1.0);
}