permutation for two different list

[aj3423]

Hi,
I got a permutation question, I got two different std::list:

list<string> slist;
slist.push_back("str111");
slist.push_back("str222");
slist.push_back("str333");

list<int> ilist;
ilist.push_back(100);
ilist.push_back(200);

I need the permutation for both two lists(sorry I don't know how to explain this in English), the result should be like this:

------ one permutation ------
str111 str222 str333
100 200
------ one permutation ------
str111 str222 str333
200 100
------ one permutation ------
str111 str333 str222
100 200
------ one permutation ------
str111 str333 str222
200 100
------ one permutation ------
str222 str111 str333
100 200
------ one permutation ------
str222 str111 str333
200 100
------ one permutation ------
str222 str333 str111
100 200
------ one permutation ------
str222 str333 str111
200 100
------ one permutation ------
str333 str111 str222
100 200
------ one permutation ------
str333 str111 str222
200 100
------ one permutation ------
str333 str222 str111
100 200
------ one permutation ------
str333 str222 str111
200 100

here's my code:

#include <iostream>
#include <string>
#include <list>
#include <algorithm>
using namespace std;


template <typename value_t>
void dump_list(const list<value_t>& lst) {
	for_each(lst.begin(), lst.end(), [](const value_t& value) {
		cout << value << " ";
	});
	cout << endl;
}

int main() {
	list<string> slist;
	slist.push_back("str111");
	slist.push_back("str222");
	slist.push_back("str333");

	list<int> ilist;
	ilist.push_back(100);
	ilist.push_back(200);

	do {
		do {
			cout << "------ one permutation ------" << endl;
			dump_list(slist);
			dump_list(ilist);
		} while(next_permutation(ilist.begin(), ilist.end()));
	} while(next_permutation(slist.begin(), slist.end()));
}

see, there are two do while loop, if I need a permutation with more than two lists, there'll be more and more do-while loops, that's make code looks urgly, I wonder if stl has some tricky way that can do this with just one next_permutation? maybe write some helper functor?

Thanks.

[helios]

Hmm... Maybe something like this?

template <typename T, typename Iterator>
void recursive_iterator(const T &metalist, Iterator i, Iterator end){
    if (i != end){
        do {
            Iterator next = i;
            ++next;
            recursive_iterator(metalist, next, end);
        } while (next_permutation(i->begin(), i->end()));
        return;
    }
    cout << "------ one permutation ------" << endl;
    for (auto j = metalist.begin(), e = metalist.end(); j != e; ++j)
        dump_list(*j);
}

//metalist may be a container of containers of strings.
template <typename T>
void cartesian_product_of_permutations(const T &metalist){
    recursive_iterator(metalist, metalist.begin(), metalist.end());
}

[aj3423]

Thanks, but I still don't understand how to use this, like for a three-list-situation

list<string> slist;
list<int> ilist
list<char> clist;

[helios]

Oh, they're different types. I didn't notice that.

This is very naughty code:

#include <iostream>
#include <string>
#include <list>

struct NullPointer{
	NullPointer *data;
	NullPointer *next;
};

template <typename T, typename NodeT>
struct BadList{
	T data;
	NodeT *next;
	~BadList(){
		delete next;
	}
};

template <typename T2>
BadList<T2, NullPointer> *New(const T2 &data){
	BadList<T2, NullPointer> *ret = new BadList<T2, NullPointer>;
	ret->data = data;
	ret->next = 0;
	return ret;
}

template <typename T2, typename NodeT2>
BadList<T2, NodeT2> *cons(const T2 &data, NodeT2 *list){
	BadList<T2, NodeT2> *ret = new BadList<T2, NodeT2>;
	ret->data = data;
	ret->next = list;
	return ret;
}

template <typename T, typename Function>
void iterator(T *list, Function &f){
	if (!list)
		return;
	f(list->data);
	iterator(list->next, f);
}

template <typename Function>
void iterator(NullPointer *list, Function &f){}

struct MyFunction{
	template <typename T>
	void operator()(const T &data){
		auto i = data.begin(), e = data.end();
		for (; i != e; ++i)
			std::cout <<*i<<std::endl;
	}
};

int main(){
	std::list<int> list1;
	std::list<std::string> list2;
	std::list<double> list3;
	list1.push_back(42);
	list1.push_back(84);
	list2.push_back("Hello, ");
	list2.push_back("World!");
	list3.push_back(3.141592);
	list3.push_back(2.718281);
	auto l = cons(list1, cons(list2, New(list3)));
	MyFunction f;
	iterator(l, f);
	delete l;
}

[aj3423]

Thanks helios, I got your "use a wrapper" idea.

[helios]

Well, since I've already been driven insane making this, I may as well post it.
Here's how to make recursive iterators:

template <typename T, typename Function>
struct recursive_iterator{
	T *list;
	Function *f;
	void operator()() const{
		auto next = get_recursive_iterator(this->list->next, *this->f);
		(*this->f)(this->list->data, next);
	}
};

template <typename T2, typename Function>
recursive_iterator<T2, Function> get_recursive_iterator(T2 *list, Function &f){
	recursive_iterator<T2, Function> ret;
	ret.list = list;
	ret.f = &f;
	return ret;
}

template <typename T>
struct recursive_iterator<NullPointer, T>{
	NullPointer *list;
	T *f;
	void operator()() const{}
};

struct MyOtherFunction{
	template <typename T1, typename T2>
	void operator()(const T1 &data, const T2 &iterator){
		iterator();
		auto i = data.begin(), e = data.end();
		for (; i != e; ++i)
			std::cout <<*i<<std::endl;
	}
};