Having trouble with [LNK1169 one or more multiply defined symbols found]

[javascripty]

This works when combined into a single file, but when I try to split it into main.cpp, BigInt.cpp, and BigInt.h it comes up with the following errors. Any idea how to fix this?

LNK2005	"class BigInt __cdecl operator*(class BigInt &,class BigInt &)" (??D@YA?AVBigInt@@AAV0@0@Z) already defined in BigInt.obj
Error	LNK2005	"class BigInt __cdecl operator+(class BigInt &,class BigInt &)" (??H@YA?AVBigInt@@AAV0@0@Z) already defined in BigInt.obj
Error	LNK1169	one or more multiply defined symbols found

main.cpp

#include "BigInt.h"
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

int main() {

	BigInt B1("2"); 
	BigInt B2("6");
	BigInt B4 = /*B1 + B2;*/ pow(B1, B2);//  B1 * B2;

	std::cout << std::endl << std::endl;
	std::cout << "B1^B2 is " << B4 << std::endl;

	std::cin.get();
	return 0;
}

BigInt.h

#pragma once
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>

class BigInt {
	std::vector<int> aBigInt;
public:
	BigInt(const BigInt& a);
	BigInt(std::string = 0);

	BigInt(int); // for pow counter
	BigInt(std::vector<int>);
	BigInt& operator+=(BigInt&);
	BigInt& operator*=(BigInt &);
	BigInt& operator|(BigInt&);
	std::vector<int>getBigInt() const;
	void setBigInt(std::vector<int>);
	void push_back(int);
	void clear();
	void removeLeadZeroes();
	void removeTrailZeroes();
};

bool operator!=(BigInt&, BigInt &);
bool operator==(BigInt&, BigInt &);
BigInt operator+(BigInt&, BigInt&);
BigInt operator*(BigInt&, BigInt&);
BigInt operator ^(BigInt&, BigInt&);
BigInt pow(BigInt&, BigInt&);
BigInt operator+(BigInt &lhs, BigInt &rhs) { return lhs += rhs; }
BigInt operator*(BigInt &lhs, BigInt &rhs) { return lhs *= rhs; }
std::ostream& operator<<(std::ostream& out, BigInt a);
int stringToInt(std::string);

BigInt.cpp

#include "BigInt.h"
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>


void BigInt::removeLeadZeroes()
{
	for (auto x : aBigInt)
	{
		while (x == 0) { aBigInt.pop_back(); }
		if (x != 0) { break; }
	}
}

void BigInt::removeTrailZeroes()
{
	while (!aBigInt.empty() && aBigInt[aBigInt.size() - 1] == 0)
	{
		aBigInt.pop_back();
	}
}

void removeLeadZero(std::vector<int> &x)
{
	for (auto y : x)
	{
		while (y == 0) { x.pop_back(); }
		if (y != 0) { break; }
	}
}

void removeTrailZero(std::vector<int> &x)
{
	while (!x.empty() && x[x.size() - 1] == 0)
	{
		x.pop_back();
	}
}

std::vector<int> BigInt::getBigInt() const { return aBigInt; }

void BigInt::setBigInt(std::vector<int> x)
{
	aBigInt = x;
}

void BigInt::push_back(int x)
{
	aBigInt.push_back(x);
}

void BigInt::clear()
{
	aBigInt.clear();
}

BigInt::BigInt(const BigInt& other) :aBigInt(other.aBigInt) {}

/*(BigInt& BigInt::operator=(BigInt a) {
this->aBigInt.swap(a.aBigInt);
return *this;
}*/

/*int stringToInt(std::string x)
{
return stoi(x);
}*/

BigInt::BigInt(std::string num) {
	std::vector<int> vec;
	for (auto x : num) { vec.push_back(x - '0'); }
	for (auto x : vec) { aBigInt.push_back(x); }

	//for (auto x : aBigInt) { std::cout << x; }
	/*std::transform(num.rbegin(), num.rend(), std::back_inserter(aBigInt),
	[](char c) { return (int)c - '0'; });*/
	//removeTrailZeroes();
	for (auto x : num) { std::cout << x; } std::cout << " ";
}

BigInt::BigInt(std::vector<int> v)
{
	aBigInt = v;
}

BigInt::BigInt(int x)
{
	std::vector<int> v{ x };
	aBigInt = v;  
}

BigInt pow(BigInt &lhs, BigInt &rhs)
{
	std::cout << std::endl << std::endl;

	if (rhs == BigInt(0)) { return BigInt(1); }

	BigInt main(1);
	BigInt copy(lhs.getBigInt());

	std::vector<int> temp;
	std::vector<int> toReverse;

	BigInt counter(0);
	BigInt incrementer(1);

	int testtotal = 1;
	int test = 2;

	std::cout << std::endl;
	while (counter != rhs)
	{
		counter += incrementer;
		main | copy;
		std::cout << main << "--";
	}
	return main;
}

BigInt operator ^(BigInt &lhs, BigInt &rhs)
{

	BigInt copy(lhs.getBigInt());


	BigInt counter(-1); // offset counter by 1
	BigInt incrementer("1");

	while (counter != rhs)
	{
		//std::cout << "<counter: " << counter << " > ";
		//std::cout << "<copy: " << copy << " > ";
		counter += incrementer;

		lhs *= copy;
		std::cout << "x";
	}
	std::cout << lhs << "<THIS>";
	return lhs;
}

bool operator!=(BigInt& lhsBigInt, BigInt & rhsBigInt)
{

	///std::cout << lhsBigInt << "LHS" << std::endl << rhsBigInt << "rhs";
	for (const auto &x : lhsBigInt.getBigInt())
	{
		for (const auto &y : rhsBigInt.getBigInt())
		{
			if (x != y) { return true; }
		}
	}
	return false;
}

bool operator==(BigInt &lhs, BigInt &rhs)
{
	if (lhs != rhs) { return false; }
	return true;
}


BigInt& BigInt::operator *=(BigInt& rhsBigInt)
{

	std::vector<int> zeroCheck = { 0 };
	if (aBigInt == zeroCheck || rhsBigInt.aBigInt == zeroCheck)
	{
		aBigInt = { 0 };
		return *this;
	}

	int lhsSize = aBigInt.size();
	int rhsSize = rhsBigInt.aBigInt.size();
	std::vector<int> product(aBigInt.size() + rhsBigInt.aBigInt.size()); // ,0
	auto lhsIndex = 0;
	auto rhsIndex = 0;
	//for (auto i = 0; i < lhsSize; ++i) // l -> r
	for (auto i = lhsSize - 1; i >= 0; --i) // r -> l
	{
		int overflow = 0;
		int lhsDigit = aBigInt[i];
		rhsIndex = 0; // < shift each result

					  //for (auto i = 0; i < rhsSize; ++i) // l -> r
		for (auto i = rhsSize - 1; i >= 0; --i) // r -> l
		{
			int rhsDigit = rhsBigInt.aBigInt[i];// -'0';
			int sum = lhsDigit * rhsDigit + product[lhsIndex + rhsIndex] + overflow;
			overflow = sum / 10;
			product[lhsIndex + rhsIndex] = sum % 10;
			++rhsIndex;
		}

		if (overflow > 0) { product[lhsIndex + rhsIndex] += overflow; }
		++lhsIndex;
	}

	this->aBigInt = product;
	this->removeTrailZeroes();  // removes leading zeroes
	return *this;
}

BigInt& BigInt::operator |(BigInt& rhsBigInt)
{

	std::vector<int> zeroCheck = { 0 };
	if (aBigInt == zeroCheck || rhsBigInt.aBigInt == zeroCheck)
	{
		aBigInt = { 0 };
		return *this;
	}

	int lhsSize = aBigInt.size();
	int rhsSize = rhsBigInt.aBigInt.size();
	std::vector<int> product(aBigInt.size() + rhsBigInt.aBigInt.size()); // ,0
	auto lhsIndex = 0;
	auto rhsIndex = 0;
	for (auto i = 0; i < lhsSize; ++i) // l -> r
									   //for (auto i = lhsSize - 1; i >= 0; --i) // r -> l
	{
		int overflow = 0;
		int lhsDigit = aBigInt[i];
		rhsIndex = 0; // < shift each result

		for (auto i = 0; i < rhsSize; ++i) // l -> r
										   //for (auto i = rhsSize - 1; i >= 0; --i) // r -> l
		{
			int rhsDigit = rhsBigInt.aBigInt[i];// -'0';
			int sum = lhsDigit * rhsDigit + product[lhsIndex + rhsIndex] + overflow;
			overflow = sum / 10;
			product[lhsIndex + rhsIndex] = sum % 10;
			++rhsIndex;
		}

		if (overflow > 0) { product[lhsIndex + rhsIndex] += overflow; }
		++lhsIndex;
	}

	this->aBigInt = product;
	this->removeTrailZeroes();  // removes leading zeroes
	return *this;
}

BigInt& BigInt::operator +=(BigInt& rhs)
{
	auto lhsCopy = aBigInt;
	std::vector<int> zeroes(int(rhs.aBigInt.size() - lhsCopy.size()));
	lhsCopy.insert(lhsCopy.begin(), zeroes.begin(), zeroes.end());

	std::vector<int> sum(std::max(rhs.aBigInt.size(), lhsCopy.size()) + 1);
	int overflow = 0;

	std::transform(rhs.aBigInt.crbegin(), rhs.aBigInt.crend(), lhsCopy.crbegin(), sum.rbegin(),
		[&overflow](const int x, const int y)
	{
		int sum = x + y + overflow;
		overflow = sum / 10;
		return sum % 10;
	});

	sum[0] = overflow;
	aBigInt.clear();
	aBigInt.insert(aBigInt.end(), sum.rbegin(), sum.rend());
	this->removeTrailZeroes();
	return *this;
}

std::ostream& operator <<(std::ostream& out, BigInt a)
{
	auto vec = a.getBigInt();
	std::reverse(vec.begin(), vec.end());
	for (auto x : vec) { out << x; }
	return out;
}

[keskiverto]

You have

BigInt operator+(BigInt &lhs, BigInt &rhs) { return lhs += rhs; }
BigInt operator*(BigInt &lhs, BigInt &rhs) { return lhs *= rhs; }

in the header. You include the header in both translation units. That is why linker gets them more than once.


You would get the same "multiply defined symbols" error for this pair:
foo.cpp

void foo()
{
}

bar.cpp

void foo()
{
}

int main()
{
  foo();
}

Move the implementations into one of the source files and leave only declaration into the header, just like you do with the other functions.

Alternatively, use the inline specifier: https://en.cppreference.com/w/cpp/language/inline



EDIT:
What have you here?

BigInt operator+(BigInt &lhs, BigInt &rhs) { return lhs += rhs; }

foo = fubar + gaz;

Lets (pseudo)write the same without function:

BigInt &lhs = fubar;
BigInt &rhs = gaz;
lhs += rhs; // means: fubar += gaz
foo = lhs; // means: foo = fubar 

Your foo+bar modifies the foo!!
Furhermore, you cannot call it with these:

const BigInt foo;
const BigInt bar;
foo + bar; // error: foo is const, error: bar is const 

Is that your intention?
It differs from int answer = 35 + 7;, where 35 does not change, and both 35 and 7 are const.

[javascripty]

I completely overlooked that - Got it now - thank you very much!