vector<T> joinen

[bluber22]

Wie kann ich einen konstanten Vektor mit der Vereinigung zweier anderer konstanter Vektoren initialisieren? C++11

[brotbernd]

Das kommt darauf an, was Du wirklich mit Vereinigung meinst.
Das http://www.cplusplus.com/reference/algorithm/set_union/ ?

[bluber22]

Ja, das meine ich.

[314159265358979]

#include <iostream>
#include <iterator>
#include <utility>
#include <vector>

template <typename Iter>
struct joining_iterator : std::iterator<std::input_iterator_tag, typename Iter::value_type>
{
	Iter r1begin;
	Iter r1end;
	Iter r2begin;

	typedef typename Iter::value_type value_type;

	joining_iterator(Iter r1begin, Iter r1end, Iter r2begin)
		: r1begin(r1begin)
		, r1end(r1end)
		, r2begin(r2begin)
	{}

	value_type& operator * ()
	{
		return const_cast<value_type&>(**static_cast<joining_iterator const*>(this));
	}

	value_type const& operator * () const
	{
		if(r1begin != r1end)
			return *r1begin;

		return *r2begin;
	}

	value_type* operator -> ()
	{
		return &**this;
	}

	value_type const* operator -> () const
	{
		return &**this;
	}

	joining_iterator& operator ++ ()
	{
		if(r1begin != r1end)
			++r1begin;
		else
			++r2begin;

		return *this;
	}

	joining_iterator operator ++ (int)
	{
		joining_iterator tmp(*this);
		++*this;
		return tmp;
	}

	friend bool operator == (joining_iterator const& first, joining_iterator const& second)
	{
		return first.r1begin == second.r1begin && first.r1end == second.r1end && first.r2begin == second.r2begin;
	}

	friend bool operator != (joining_iterator const& first, joining_iterator const& second)
	{
		return !(first == second);
	}
};

template <typename Iter>
std::pair<joining_iterator<Iter>, joining_iterator<Iter>> join_ranges(Iter begin1, Iter end1, Iter begin2, Iter end2)
{
	return std::make_pair(joining_iterator<Iter>(begin1, end1, begin2), joining_iterator<Iter>(end1, end1, end2));
}

int main()
{
	std::vector<int> a = { 0, 1, 2, 3, 4 };
	std::vector<int> b = { 5, 6, 7, 8, 9 };

	auto range = join_ranges(a.begin(), a.end(), b.begin(), b.end());

	std::vector<int> c(range.first, range.second);

	for(int i : c)
		std::cout << i << '\n';
}

0 1 2 3 4 5 6 7 8 9

[Michael E.]

Quark, mal wieder, leider. Das ist leider nur eine maximal umständliche Version, zwei Container hintereinanderzuhängen. Mit der sortierten Vereinigung hat das gar nichts zu tun.

[bluber22]

und wie mache ich es dann einfacher, zwei unsortiete Container aneinanderzuhängen?

[einwurf]

Auf die Schnelle,eventuell geht es noch einfacher:

#include <iostream>
#include <algorithm>
#include <vector>
int main()
{
 const std::vector<int> v1 {3,4,1,5};
 const std::vector<int> v2 {2,4,5,1,6,7};
 const std::vector<int> v3 = ([&v1,&v2]()->std::vector<int> 
 {
  std::vector<int> result;
  std::set_union(v1.begin(),v1.end(),v2.begin(),v2.end(),std::back_inserter(result));
  std::sort(result.begin(),result.end());
  auto new_end = std::unique(result.begin(),result.end());
  return std::vector<int>(result.begin(),new_end);
 })();
  std::for_each(v3.begin(),v3.end(),[](int i) { std::cout << i << ' ';});
 return 0;
}

[camper]

einwurf schrieb:

Auf die Schnelle,eventuell geht es noch einfacher:
...

set_union erfordert bereits sortierte Eingangssequenzen. Das Sortieren muss also ggf. bereits vorher durchgeführt werden.

[bluber22]

Ich brauche weder Sortieren noch Unique.

[Tachyon]

So:

#include <vector>
#include <set>

int main()
{
    std::vector<float> const v1(...);
    std::vector<float> const v2(...);

    std::set<float> union_set;
    union_set.insert(v1.begin(), v1.end());
    union_set.insert(v2.begin(), v2.end());

    //wenn es denn ein const vector sein muss...

    std::vector<float> const union_vector(union_set.begin(), union_set.end());
    //fertig    
}

[314159265358979]

Michael E. schrieb:

Das ist leider nur eine maximal umständliche Version, zwei Container hintereinanderzuhängen.

Sie ist vielleicht umständlich, aber wenigstens cool.

Michael E. schrieb:

Mit der sortierten Vereinigung hat das gar nichts zu tun.

Er hat nie was von sortierter Vereinigung gesagt, folglich ist das genau das erfragte.

[Tachyon]

314159265358979 schrieb:

Er hat nie was von sortierter Vereinigung gesagt, folglich ist das genau das erfragte.

In einer Vereinigung gibt es keine Doubletten, ob sie nun sortiert ist, oder nicht.

[Michael E.]

314159265358979 schrieb:

Er hat nie was von sortierter Vereinigung gesagt, folglich ist das genau das erfragte.

Constructs a sorted range beginning in the location pointed by result with the set union of the two sorted ranges [first1,last1) and [first2,last2) as content.

bluber22 schrieb:

Ja, das meine ich.

[314159265358979]

Na gut, ausnahmsweise. Mein Iterator ist trotzdem cooler als irgendein Algorithmus!

[Ethon]

Aber .. ?

Ich brauche weder Sortieren noch Unique.

[original poster]

Warum geht folgendes nicht?

template <typename ListType> inline ListType append(const ListType& v1, const ListType& v2)
{
	ListType result;
	set_union(v1.begin(), v1.end(), v2.begin(), v2.end(), back_inserter(result));
	return result;
}