#include <iostream>
#include <list>
#include <numeric>
#include <chrono>
#include <string>
#include <memory>
using namespace std;
template< typename T, template<typename, typename> class Container>
class ContainerTemplate: public Container<T, allocator<T>>
{
public:
size_t inlet_whole_length()
{
size_t result(0);
for(auto it: *this)
{
result+=it.size();
}
return result;
}
T whole_inlet_containers2container()
{
T result;
result.reserve(inlet_whole_length());
for(auto a:*this)result.insert(result.end(), a.begin(), a.end());
return result;
}
};
template< typename T, template<typename, typename> class Container>
class ContainerTemplate2: public Container<T, allocator<T>>
{
public:
size_t inlet_whole_length()
{
size_t result(0);
for(const auto &it: *this) //ссылка важна здесь
{
result+=it.size();
}
return result;
}
T whole_inlet_containers2container()
{
T result;
result.reserve(inlet_whole_length());
for(const auto &a:*this)result.insert(result.end(), a.begin(), a.end());
return result;
}
};
int main()
{
const std::size_t Size = 75000;
ContainerTemplate<string, list> vs;
ContainerTemplate2<string, list> vs2;
for (std::size_t i = 0; i < Size; i++)
{
auto str = std::string(i,'s');
vs.push_back(str);
vs2.push_back(str);
}
auto start = std::chrono::high_resolution_clock::now();
auto str = vs.whole_inlet_containers2container();
auto end = std::chrono::high_resolution_clock::now();
std::chrono::duration<double> diff = end-start;
std::cout << "Time without ref "<< diff.count() << " s\n";
start = std::chrono::high_resolution_clock::now();
auto str2 = vs2.whole_inlet_containers2container();
end = std::chrono::high_resolution_clock::now();
diff = end-start;
std::cout << "Time with ref "<< diff.count() << " s\n";
}
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