Блог

 #include <iostream>
#include <vector>
using namespace std;


void testfn(double* v1, double *v2, double *v3, int n);//I must use this function

class CLS{
private:
    vector<double> v;
public:
    CLS(vector<double> vin);
    CLS operator (CLS amp; A);
    CLS operator*(CLS amp; A);
};

CLS::CLS(vector<double> vin)
{
    v=vin;
}

CLS CLS::operator*(CLS amp;A){
    //assuming the two vectors have the same length
    vector<double> vtmp(v.size(),0);
    testfn(amp;*A.v.begin(),amp;*v.begin(),amp;*vtmp.begin(),(int)A.v.size());
    CLS C(vtmp);
    return C;
}

CLS CLS::operator (CLS amp;A){
    //assuming the two vectors have the same length
    vector<double> vtmp(v.size(),0);
    testfn(amp;*A.v.begin(),amp;*v.begin(),amp;*vtmp.begin(),(int)A.v.size());
    CLS C(vtmp);
    return C;
}

void testfn(double* v1, double *v2, double *v3, int n)
{
    for (int i=0;i<n;i  )
    {
        *v3=*v1 *v2;
          v1;
          v2;
          v3;
    }
}

int main(){
    vector<double> v1(100,1.0), v2(100,2.0), v3(100,0.0);
    CLS C1(v1),C2(v2),C3(v3);
    CLS C4=C1*(C1 (C2*C3 C2))*C1*C2*C3 C1 C2 C3;
    return 0;
}
  

Я создаю CLS класса и определил два оператора и *. Я хочу использовать эти операторы так же просто, как мы используем и * для целых и двойных чисел. Поэтому у меня есть тестовая строка в основном CLS C4=C1*(C1 (C2*C3 C2))*C1*C2*C3 C1 C2 C3; . Однако я получаю тонны ошибок при компиляции этого кода с использованием gcc. Я недостаточно знаком с правилами перегрузки оператора. Как я должен изменить определение (возможно, просто параметры?) * и , чтобы CLS C4=C1*(C1 (C2*C3 C2))*C1*C2*C3 C1 C2 C3; это было допустимо?

Дополнения: Я не знаю, как использовать параметр const для операторов и * , поскольку определение этих двух операторов включает в себя другую функцию testfn , параметры которой являются double* вместо const double* . Более того, я не хочу изменять какую-либо часть в определении testfn , потому что в моем реальном коде это соответствует функции в LAPACK, которую я абсолютно не имею права изменять.

Лучше определить operator and operator* как дружественную функцию, чтобы, если будут неявные преобразования из какого-либо другого типа в CLS , тогда оператор можно было использовать. Если это функция-член, то, если первый операнд не является CLS , он не будет найден.

 friend CLS operator (CLS lhs, const CLSamp; rhs) 
{
  // Do your logic here
  return lhs; 
}
  

Вам следует использовать пробелы в вашем коде, это ужасно читать. Не используйте заглавные буквы как для имен типов, так и для переменных, это также ужасно читать.

Это не обязательно, но небольшая оптимизация, передайте аргумент конструктора по ссылке, а затем инициализируйте v элемент в списке инициализации конструктора (не присваивая ему в теле):

 CLS::CLS(const vector<double>amp; vin) : v(vin)
{
}
  

Я бы добавил новый конструктор, который принимает желаемый размер и немедленно приводит v элемент к этому размеру, что упрощает приведенный ниже код:

 CLS::CLS(int n) : v(n, 0)
{
}
  

Сначала добавьте const в параметр функции и саму функцию-член:

 CLS CLS::operator*(const CLSamp; a) const {
                   ^^^^^         ^^^^^
  

Затем по умолчанию создается пустой C объект для результата с векторным элементом желаемого размера:

     //assuming the two vectors have the same length
    CLS result(v.size());
  

Если вы создаете копии вектора данных и работаете с этими копиями, то вы можете сделать функцию-член и ее аргумент const:

     vector<double> v1 = a.v;
    vector<double> v2 = v;
  

Теперь вы можете получать неконстантные указатели на данные в этих векторах, и вы можете записывать выходные данные прямо в C.v вместо того, чтобы записывать в vtmp , а затем копировать это в возвращаемый объект:

     testfn(amp;*v1.begin(), amp;*v2.begin(), amp;*result.v.begin(), v.size());
  

Наконец, верните результат:

     return resu<
}
  

И точно такие же изменения для другой функции:

 CLS CLS::operator (const CLSamp; a) const {
    //assuming the two vectors have the same length
    CLS result(v.size());
    vector<double> v1 = a.v;
    vector<double> v2 = v;
    testfn(amp;*v1.begin(), amp;*v2.begin(), amp;*result.v.begin(), v.size());
    return resu<
}
  

Теперь он сможет принимать аргументы const, поэтому должен работать с временными объектами, которые создаются каждым выражением C1 C2 или C3*C4 .

Код немного менее эффективен из-за дополнительных копий данных, но оптимизация в конструкторе помогает этому. Даже эти недостатки могут быть решены, если вы можете использовать C 11, но для этого требуется больше работы.

Во-первых, C 11 предоставляет vector<T>::data() возможность получения указателя, что намного понятнее, чем amp;*v.begin() . (Это не было частью стандарта C до C 11, но GCC предоставляет это даже для C 98). Вы можете изменить приведенный выше код, чтобы использовать v.data() вместо amp;*v.begin() , как показано ниже.

В C 11 вы можете добавить дополнительные перегрузки, которые работают с временными объектами, путем привязки (неконстантных) ссылок rvalue на временные объекты. Поскольку ссылки на значения rvalue предоставляют вам неконстантный доступ к временным объектам, вам не нужно делать копии их данных, чтобы получить неконстантные указатели, и вы можете использовать их напрямую. Добавьте эти перегрузки оператора в дополнение к исходным, показанным выше:

 CLS CLS::operator (CLSamp;amp; a) amp;amp; {
    //assuming the two vectors have the same length
    CLS result(v.size());
    testfn(a.v.data(), v.data(), result.v.data(), v.size());
    return resu<
}

CLS CLS::operator*(CLSamp;amp; a) amp;amp; {
    //assuming the two vectors have the same length
    CLS result(v.size());
    testfn(a.v.data(), v.data(), result.v.data(), v.size());
    return resu<
}
  

Это позволяет избежать создания каких-либо копий внутри промежуточных временных объектов, созданных вашими арифметическими выражениями. Я также считаю, что это намного проще для понимания и легче для чтения.

Полный рабочий пример находится на http://coliru.stacked-crooked.com/a/6e40d20eb7f1e9fc

Необычное требование использовать testfn со всеми неконстантными параметрами немного странно, но это … мм.. неохотно приемлемый неприемлемо для случая сложных выражений — первые два параметра testfn должны быть const double* .

Обоснование: стандарт C требует привязки к временным файлам const references — вот некоторые интересные подробности

@Resorter говорит:

«Спасибо, что дали мне знать, и я хотел бы научиться. Но вы уверены, что это решает мою проблему? Я действительно хочу сначала решить эту проблему.»

[где это ‘переместить конструктор’ и ‘переместить назначение’]

Следующая «рыба» предполагает, что вы прочитали / изучили поиск конструктора перемещения и назначение перемещения и правила 5/3/0,

Дополнительный учебный материал: исключение копирования — когда компилятору разрешено пропускать конструкторы копирования / перемещения, даже если они могут иметь побочные эффекты.

 // some implementations
void testfn0(const double* v1, const double *v2, double *v3, int n) {
  for(int i=0; i<n; i  ) {
    v3[i]=v1[i] v2[i];
  }
}

void testfn1(double* v1, double *v2, double *v3, int n) {
  for(int i=0; i<n; i  ) {
    v3[i]=v1[i]*v2[i];
  }
}

class CLS {
  std::vector<double> v;
public:
  // constructor taking a const reference
  CLS(const std::vector<double>amp; in) : v(in) {
    std::cout << "copy vec" << std::endl;
  }

  // extra constructor with rvalue reference: it will "canibalize" the parameter
  CLS(std::vector<double>amp;amp; in) : v(in) {
    std::cout << "move vec" << std::endl;
  }

  // Rule of 5 applied
  // Copy constructor
  CLS(const CLSamp; other) : v(other.v) {
    std::cout << "copy CLS" << std::endl;
  }
  // Move constructor
  CLS(CLSamp;amp; other) : v(std::move(other.v)) {
    std::cout << "move CLS" << std::endl;
  }
  ~CLS() { }

  // Copy assgn
  CLSamp; operator=(const CLSamp; o) {
    this->v=o.v;
    std::cout << "assgn CLS" << std::endl;
    return *this;
  }
  // Move assgn
  CLSamp; operator=(CLSamp;amp; other) {
    this->v=std::move(other.v);
    std::cout << "move CLS" << std::endl;
    return *this;
  }

  // WILL NOT WORK WITHOUT const FOR COMPLEX EXPRESSIONS
  //                       |
  //              ----------
  //              V
  CLS operator (const CLSamp; rhs) {
    std::vector<double> vtmp(v.size(),0);
    testfn0(amp;*rhs.v.begin(),amp;*v.begin(),amp;*vtmp.begin(),(int)rhs.v.size());

    CLS ret(std::move(vtmp));
    return ret;
  }

  // WILL NOT WORK WITHOUT const FOR COMPLEX EXPRESSIONS
  //                       |
  //              ----------
  //              V
  CLS operator*(const CLSamp; rhs) {
    std::vector<double> vtmp(v.size(),0);
    testfn1(amp;*rhs.v.begin(),amp;*v.begin(),amp;*vtmp.begin(),(int)rhs.v.size());

    CLS ret(std::move(vtmp));
    return ret;
  }
};

int main() {
  std::cout << "n--- inits " << std::endl;
  CLS a(std::vector<double>{1,2,3}); // move vec
  CLS b(std::vector<double>{3,2,1}); // move vec

  std::cout << "n--- add " << std::endl;
  CLS c=a b; // move vec and 'silence' (copy elision)
  std::cout << "n--- mul " << std::endl;
  CLS d=a*b; // move vec and 'silence' (copy elision)

  std::cout << "n--- copy " << std::endl;
  CLS m=c; // Copy CLS - constructor

  std::cout << "n--- move " << std::endl;
  CLS n=std::move(d); // Move CLS - constructor

  std::cout << "n--- assgn (d=c) and copy (x=c)" << std::endl;
  CLS x=d=c;
}