Как решить ошибку multyply defined?

Question

[Игорь Кузьмич]

помогите, у меня тут повторное определение, я не пойму что делать, #pragma once написал, не помогает
мне надо сгенерировать много рандомных названий, но ошибка компиляции все портит.
с++17

выдает ошибку:

Severity	Code	Description	Project	File	Line	Suppression State
Error	LNK2005	"class std::mersenne_twister_engine<unsigned __int64,64,312,156,31,-5403634167711393303,29,6148914691236517205,17,8202884508482404352,37,-2270628950310912,43,6364136223846793005> kapt0xa::default_randomizer" (?default_randomizer@kapt0xa@@3V?$mersenne_twister_engine@_K$0EA@$0BDI@$0JM@$0BP@$0?EKPNJAKFFGJJOGBH@$0BN@$0FFFFFFFFFFFFFFFF@$0BB@$0HBNGHPPPONKGAAAA@$0CF@$0?IBBCAAAAAAAAA@$0CL@$0FIFBPECNEMJFHPCN@@std@@A) already defined in main.obj	testing_stuff	C:\Users\HP\source\repos\testing_stuff\testing_stuff\random_string.obj	1

main.cpp:

#include "random_string.h"
#include <fstream>

using namespace std;
using namespace kapt0xa;

int main()
{
	ofstream fout("random_busnames.txt");
	auto words = MakeRandomWords(1000);
	auto phrases = MakeRandomPhrases(500, words);
	UnorderedUnique(phrases);
	SaveStrings(phrases, fout);
}

random_string.h:

#pragma once

#include <string>
#include <random>
#include <iostream>
#include <vector>
#include <ctime>

namespace kapt0xa
{
	using std::string;
	using std::ostream;
	using std::istream;
	using strings = std::vector<string>;
	using namespace std::string_literals;
	using Randomizer = std::mt19937_64;

	Randomizer default_randomizer(std::time(0));
	struct AvailableChars
	{
		const string alphabet = "abcdefghijklmnopqrstuvwxyz"s;
		const string caps = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"s;
		const string digits = "0123456789"s;
		const string punctuators = "          ---/"s;

		char RandomLetter(Randomizer& randomizer) const;
		char RandomGrandLetter(Randomizer& randomizer) const;
		char RandomDigit(Randomizer& randomizer) const;
		char RandomPunctuator(Randomizer& randomizer) const;

	} const default_available_chars;

	string MakeRandomWord(Randomizer& randomizer = default_randomizer, size_t min_size = 4, size_t max_size = 10, const AvailableChars& letters = default_available_chars);
	strings MakeRandomWords(size_t count, Randomizer& randomizer = default_randomizer, size_t min_size = 4, size_t max_size = 10, const AvailableChars& letters = default_available_chars);
	string MakeRandomPhrase(const strings& words, size_t min_word_count = 1, size_t max_word_count = 4, Randomizer& randomizer = default_randomizer, const AvailableChars& letters = default_available_chars);
	strings MakeRandomPhrases(size_t count, const strings& words, size_t min_word_count = 1, size_t max_word_count = 4, Randomizer& randomizer = default_randomizer, const AvailableChars& letters = default_available_chars);
	strings LoadStrings(istream& in);
	void SaveStrings(const strings& data, ostream& out);
	strings& UnorderedUnique(strings& data);
}

random_string.cpp в коментах скину если надо

Comments

[Dmitrii]

Сократи количество исходников, пожалуйста. кидать абсолютно все бессмысленно

[Игорь Кузьмич]

random_string.cpp:

#include "random_string.h"
#include <unordered_set>
#include <cassert>

using std::move;

namespace kapt0xa
{
	using UniqueUnordStr = std::unordered_set<string>;
	using std::getline;

	template<typename Container>
	auto RandomElement(const Container& container, Randomizer& randomizer)
	{
		return container[randomizer() % container.size()];
	}

	size_t RandomNum(size_t from, size_t to, Randomizer& randomizer)
	{
		assert(from < to);
		assert((to - from + 1) != 0);
		return from + randomizer() % (to - from + 1);
	}

	string MakeRandomWord(Randomizer& randomizer, size_t min_size, size_t max_size, const AvailableChars& letters)
	{
		string result;
		size_t size = RandomNum(min_size, max_size, randomizer);

		size_t type = RandomNum(0, 3, randomizer); // 0 - usual, 1 - Name, 2 - CAPS, 3 - number (4564)
		if (type == 2) // make capsed words shorter
		{
			size /= 2;
			size += 1;
		}
		if (type == 3) // make numbers shorter
		{
			size /= 3;
			size += 1;
		}

		result.reserve(size);

		for (; result.size() < size;)
		{
			switch (type)
			{
			case 0:
				result.push_back(letters.RandomLetter(randomizer));
				break;
			case 1:
				result.push_back(letters.RandomGrandLetter(randomizer));
				type = 0;
				break;
			case 2:
				result.push_back(letters.RandomGrandLetter(randomizer));
				break;
			case 3:
				result.push_back(letters.RandomDigit(randomizer));
				break;
			default:
				assert(false);
				break;
			}
		}
		return result;
	}

	strings MakeRandomWords(size_t count, Randomizer& randomizer, size_t min_size, size_t max_size, const AvailableChars& letters)
	{
		strings result;
		result.reserve(count);
		for (; result.size() < count;)
		{
			result.push_back(MakeRandomWord(randomizer, min_size, max_size, letters));
		}
		return result;
	}

	string MakeRandomPhrase(const strings& words, size_t min_word_count, size_t max_word_count, Randomizer& randomizer, const AvailableChars& letters)
	{
		string result;

		size_t size = RandomNum(min_word_count, max_word_count, randomizer);
		result.reserve(size);

		bool first_loop = true;
		for (size_t i = 0; i < size; ++i)
		{
			if (first_loop)
			{
				first_loop = false;
			}
			else
			{
				result += letters.RandomPunctuator(randomizer);
			}
		}

		return result;
	}

	strings MakeRandomPhrases(size_t count, const strings& words, size_t min_word_count, size_t max_word_count, Randomizer& randomizer, const AvailableChars& letters)
	{
		strings result;
		return result;
	}

	strings LoadStrings(istream& in)
	{
		strings result;
		size_t count;
		in >> count;
		result.reserve(count);
		while (result.size() < count)
		{
			string line;
			getline(in, line);
			result.push_back(move(line));
		}
		return result;
	}

	void SaveStrings(const strings& data, ostream& out)
	{
		out << data.size() << '\n';
		for (const string& frame : data)
		{
			out << frame << '\n';
		}
	}

	strings& UnorderedUnique(strings& data)
	{
		UniqueUnordStr unique;
		for (string& word : data)
		{
			unique.insert(move(word));
		}

		data.clear();
		data.reserve(unique.size());

		for (const string& word_raw : unique)
		{
			data.push_back(move(const_cast<string&>(word_raw)));
		}

		return data;
	}

	char AvailableChars::RandomLetter(Randomizer& randomizer) const
	{
		return RandomElement(alphabet, randomizer);
	}

	char AvailableChars::RandomGrandLetter(Randomizer& randomizer) const
	{
		return RandomElement(caps, randomizer);
	}

	char AvailableChars::RandomDigit(Randomizer& randomizer) const
	{
		return RandomElement(digits, randomizer);
	}

	char AvailableChars::RandomPunctuator(Randomizer& randomizer) const
	{
		return RandomElement(punctuators, randomizer);
	}
}

[Dmitrii]

Игорь Кузьмич, весь код можно было тупо убрать. У вас проблема двумя строками описывается.

[Игорь Кузьмич]

Dmitrii, да, но я же не знал какими именно двумя строками, я изначально вообще не туда смотрел

Answer 1

[Dmitrii]

Вы объявляете переменную в заголовочном файле, и ловите соответствующую ошибку.
В заголовочном файле нужно её объявить хотя бы extern:
extern Randomizer default_randomizer;
А, например, в main.cpp:
Randomizer default_randomizer(std::time(0));

В современных плюсах есть более элегантное решение, насколько я помню для этого можно использовать inline переменные, чтобы можно было видеть их за пределами одной единицы трансляции, без дополнительных extern'ов

Comments

[Игорь Кузьмич]

да, спасибо, проблема в 18 строке, Randomizer default_randomizer(std::time(0));