operatory: łączenie wektorów

Witam,
mam do napisania dwa operatory, które będą działać z mainem którego nie mogę modyfikować.

#include <vector>
#include <iostream>

operator +(const std::vector<double> &v1, const std::vector<double> &v2)
{
std::vector<double> pom;

for (int i=0; i<v1.size(); i++)
    {
      pom.push_back(v1[i]);

     }

     for (int i=0; i<v1.size(); i++)
    {
      pom.push_back(v2[i]);

     }

return pom;
}

operator += (std::vector<double> &v1, const std::vector<double> &v2)

{



for (int i=v1.size(); i<v1.size()+v2.size(); i++)
    {
      v1.push_back(v1[i]);

     }


return v1;
}



int main() {
std::vector<double> vector = std::vector<double> {6.7, -12.3}   + std::vector<double> {-2.7, 19};


(vector += std::vector<double> {0.5, -2.7}) += std::vector<double> {19};

for (double element: vector) {
    std::cout << element << " "; }


std::cout << std::endl; }

Wykrzacza mi się na wektorze pom nie wiedzieć czemu trakruje go jako int...
||=== Build file: "no target" in "no project" (compiler: unknown) ===|
OPERATORY.cpp||In function 'int operator+(const std::vector<double>&, const std::vector<double>&)':|
OPERATORY\ |21|error: cannot convert 'std::vector<double>' to 'int' in return|
\OPERATORY\p||In function 'int operator+=(std::vector<double>&, const std::vector<double>&)':|
OPERATORY\ p|42|error: cannot convert 'std::vector<double>' to 'int' in return|
OPERATORY\1 Ap||In function 'int main()':|
OPERATORY\pp|57|error: conversion from 'int' to non-scalar type 'std::vector<double>' requested|
OPERATORY\1cpp|60|error: no match for 'operator+=' (operand types are 'int' and 'std::vector<double>')|
OPERATORY\1cpp|24|note: candidate: int operator+=(std::vector<double>&, const std::vector<double>&)|
OPERATORY\1pp|24|note: no known conversion for argument 1 from 'int' to 'std::vector<double>&'|
||=== Build failed: 4 error(s), 0 warning(s) (0 minute(s), 0 second(s)) ===|

musisz podać typ zwracany do funkcji przeciążenia danego operatora (tak jak do zwykłej funkcji).
https://en.cppreference.com/w/cpp/language/operators

p.s.
w 2giej pętli powinno być chyba v2.size()

pisane z telefonu

@Edit
operator += musisz od nowa napisać, nie realizuje on zadania + jest nieprawidłowo napisany

plx211 napisał(a):

musisz podać typ zwracany do funkcji przeciążenia danego operatora (tak jak do zwykłej funkcji).
https://en.cppreference.com/w/cpp/language/operators

p.s.
w 2giej pętli powinno być chyba v2.size()

pisane z telefonu

@Edit
operator += musisz od nowa napisać, nie realizuje on zadania + jest nieprawidłowo napisany

std::vector<double> operator +(const std::vector<double> &v1, const std::vector<double> &v2)
{
std::vector<double> pom;

for (int i=0; i<v1.size(); i++)
    {
      pom.push_back(v1[i]);

     }

     for (int i=0; i<v2.size(); i++)
    {
      pom.push_back(v2[i]);

     }

return pom;
}

poprawiony "+" ,nie rozumiem jak ma wyglądać ten "+="

heygo1 napisał(a):

poprawiony "+" ,nie rozumiem jak ma wyglądać ten "+="

Przykładowe użycie operatorów = i +=.

a = b + c;
d += e;

Delor napisał(a):

heygo1 napisał(a):

poprawiony "+" ,nie rozumiem jak ma wyglądać ten "+="

Przykładowe użycie operatorów = i +=.

Kopiuj

a = b + c;
d += e;

wiem jak się ich używa, ale mam problem żeby przeciążenie zrobić

mam coś takiego

std::vector<double>v1& operator += (const std::vector<double>  &v2)

ale nie działa

Aby operator += zadziałał z jednym argumentem musiałbyś zaimplementować go jako metodę klasy std::vector. Bez zmian w pliku nagłówkowym nie możesz tego zrobić. Użyj wersji z dwoma argumentami.
Zwracaj typ, bez nazwy zmiennej.

@heygo1:
std::vector<double>& operator+=(std::vector<double>& a, std::vector<double> const& b);

Zauważ, że jeden operator możesz wykorzystać przy implementacji drugiego.

dobra dziękuje, wyszło:)

W końcu przy komputerze :)

Większa analiza:
Linia 5 oraz 24

operator +(const std::vector<double> &v1, const std::vector<double> &v2)

operator += (std::vector<double> &v1, const std::vector<double> &v2)

Jak pisałem wcześniej przeciążenie operatora tak jak zwykła funkcja wymaga typu zwracanego, jak widać w twoim kodzie kompilator wydedukował sobie że masz zamiar zwracać int stąd wynika błąd kompilacji który otrzymałeś:

OPERATORY.cpp||In function 'int operator+(const std::vector<double>&, const std::vector<double>&)':|
OPERATORY\ |21|error: cannot convert 'std::vector<double>' to 'int' in return|

Linie 15-19

    for (int i=0; i<v1.size(); i++)
    {
      pom.push_back(v2[i]);

     }

Miałeś tutaj poważny błąd ponieważ zwiększałeś zmienną i aż do v1.size() i próbowałeś nią indexować v2, gdyby v1 zawierało więcej elementów od v2 wykroczył byś po za zakres v2 (np. v1 = {1.0, 2.0, 3.0, 4.0); v2 = {1.0, 2.0, 3.0}) co by mogło skutkować wykrzaczeniem aplikacji poprzez przekroczenie zakresu.

#NOTKA
Jeśli nie musisz używać post [in/de]krementacji (var++ lub var--) to lepiej jest użyjać pre (++var lub --var):
https://gynvael.coldwind.pl/?id=495

#NOTKA 2
Zamiast int lepiej jak byś używał std::size_t w konstrukcji pętli (https://en.cppreference.com/w/cpp/types/size_t)

Linie 28-32

for (int i=v1.size(); i<v1.size()+v2.size(); i++)
    {
      v1.push_back(v1[i]);

     }

Prawie każda część tego kodu jest zła i niebezpieczna w użyciu, przekraczasz tutaj zakres a w dodatu ta pętla będzie wykonywała się w nieskończoność (a przynajmniej półki aplikacja się nie zcrashuje, co pewnie nastąpiło by bardzo szybko ;) ).
Lepiej by było zaimplementować ją w taki sposób:

for (auto i=0; i < v2.size(); ++i) {
  v1.push_back(v2[i]);
}

Skoro widzę że w miarę sobie poradziłeś z zadaniem pokuszę się o napisanie jak mogłeś to zaimplementować:

#include <iostream>
#include <vector>
#include <iterator> // std::ostream_iterator
#include <algorithm> // std::copy

std::vector<double>& operator += (std::vector<double>& left,
								  const std::vector<double>& right) {
	auto newSize = left.size() + right.size();
	
	// https://en.cppreference.com/w/cpp/container/vector/reserve
	left.reserve(newSize); 
	
	// https://en.cppreference.com/w/cpp/container/vector/insert
	left.insert(left.end(),
				right.begin(),
				right.end());
				
	return left;
}

std::vector<double> operator + (const std::vector<double>& first,
								const std::vector<double>& second) {
	// https://en.cppreference.com/w/cpp/container/vector/operator%3D
	std::vector<double> result = first;
	result += second;
	return result;
}


int main() {
	std::vector<double> a{1.3, 2.6, 3.1};
	std::vector<double> b{9.6, 8.2, 7.9};
	std::vector<double> vec = a + b;
	
	// https://en.cppreference.com/w/cpp/algorithm/copy
	// https://en.cppreference.com/w/cpp/iterator/ostream_iterator
	std::copy(vec.begin(),
			  vec.end(),
              std::ostream_iterator<double>(std::cout, " "));
    std::cout << "\n";
    
    vec += {1.1, 2.2, 3.3};
    
    std::copy(vec.begin(),
			  vec.end(),
              std::ostream_iterator<double>(std::cout, " "));
    std::cout << "\n";
    
	return 0;
}

Można by się także pokusić tutaj o template ;)