C++ forward_list::end方法代码示例

void insertAfterStr(forward_list<string> &flist, string flag, string insert){
	auto pre = flist.before_begin();
	auto item = flist.begin();
	while (item != flist.end() && *item != flag)
		pre++, item++;
	item == flist.end() ? flist.insert_after(pre, insert) : flist.insert_after(item, insert);
}

forward_list<string> func(forward_list<string> &il, string s1, string s2) {
    auto iter = il.begin();
    auto prev = il.before_begin();
    for (; iter != il.end(); prev = iter++)
        if (*iter == s1)
            break;
    if (iter == il.end())
        il.insert_after(prev, s2);
    else
        il.insert_after(iter, s2);
    return il;
}

void insertString(forward_list<string>& fls,string target,string insertval){
	auto cur=fls.begin();
	auto prev=fls.before_begin();
	while(cur!=fls.end()&&*cur!=target) {
	   prev=cur;
	   ++cur;
	}
	if(cur!=fls.end())
		fls.insert_after(cur,insertval);
	else{
		fls.insert_after(prev,insertval);
	}
}

forward_list<int> LinkedListsExpert::partition(forward_list<int> list, int x){
    forward_list<int> lessThanX, greaterThanX, equalX;
    forward_list<int>::iterator it = list.begin();
    while (it!=list.end()) {
        if (*it < x) {
            lessThanX.push_front(*it);
        } else if (*it > x){
            greaterThanX.push_front(*it);
        } else{
            equalX.push_front(*it);
        }
        it++;
    }
    //merge lists
    it = equalX.begin();
    while (it != equalX.end()) {
        greaterThanX.push_front(*it);
        it++;
    }
    it = lessThanX.begin();
    while (it != lessThanX.end()) {
        greaterThanX.push_front(*it);
        it++;
    }
    return greaterThanX;
}

void listCopy(forward_list<T> L, forward_list<T> &P) // reverse L and put it into P
{
    for(typename forward_list<T>::iterator start = L.begin() ; start != L.end() ; ++start)
    {
        P.push_front(*start);
    }
}

void insertString(forward_list<string> &strflst, const string &search, const string &str)
{
	auto prev = strflst.before_begin();
	auto curr = strflst.begin();
	if (!strflst.empty())
	{
		bool flag = false;
		while(curr != strflst.end())
		{
			if (*curr == search)
			{
				curr = strflst.insert_after(curr, str);
				flag = true;
			}
			else
			{
				prev = curr++;
			}
		}
		if (!flag)
		{
			strflst.insert_after(prev, str);
		}
	}
}

void printLots(forward_list<T> L, forward_list<int> P)
{
    int num_elem = 0;
    
    for (typename forward_list<T>::iterator count = L.begin() ; count != L.end() ; ++count)
    {
        num_elem = num_elem + 1;
    }
    
    while(!P.empty())
    {
        int pos = P.front();
        
        if(pos >= num_elem)
        {
            cout << "Position out of bounds!" << endl;
            return;
        }
        
        typename forward_list<T>::iterator start = L.begin();
        
        for(int i = 0 ; i < pos ; i++)
        {
            ++start;
        }
        
        cout << *start << ", ";
        
        P.pop_front();
    }
    
    cout << endl;
}

void LinkedListsExpert::printList(forward_list<int> list){
    std::forward_list<int>::iterator it;
    for (it = list.begin(); it != list.end(); it++) {
        cout << *it << "  ";
    }
    cout << "\n";
}

	void printTroopers(void) {
		for (atk_pos = attackers_fw_list.begin(); atk_pos != attackers_fw_list.end(); atk_pos++) {
			cout << "Runde:" << atk_pos->getRound() << "   --X:" << atk_pos->getLine() << "--Y:" << atk_pos->getY()
					<< "--Owner:" << atk_pos->getOwner() << "--Range:" << atk_pos->getRange() << "--DMG:"
					<< atk_pos->getRange() << "--HP:" << atk_pos->getHp() << "--Movement:" << atk_pos->getMovement()
					<< endl << endl;
		}
	};

int LinkedListsExpert::getNthToLast(forward_list<int> list, int n){
    forward_list<int>::iterator current = list.begin();
    forward_list<int>::iterator previous = list.begin();
    
    for(int i=1; i<=n; i++){
        if (current != list.end()) {
            current++;
        }
    }
    
    while (current != list.end()) {
        current++;
        previous++;
    }
    
    return *previous;
}

TypeInfo getInfoAtPosit(forward_list<TypeInfo> laListe, int laPosition) throw (PrecondVioleeExcep) {
    // version itérative
    // un itérateur sur la liste
    auto it = laListe.begin();
    int positionCourante = 1;
    // tantque l'on a pas atteint laPosition et que l'on est pas à la fin de la liste
    while ((positionCourante < laPosition) && (it != laListe.end())) {
        positionCourante++;
        // avancer dans la liste sur l'itérateur
        ++it;
    }
    if (it != laListe.end()) { // si on eu accès à laPosition
        // rendre l'élément pointé par l'itérateur
        return *it;
    } else { // sinon on lève une exception
        throw PrecondVioleeExcep("Accès imposible à l'indice " + to_string(laPosition));
    }
}

T find_last_kth(const forward_list<T>& l, int k)
{
    assert(k>=0);

    auto it = l.begin();
    for (int i=0; i<k; ++i) {
        if (it==l.end()) {
            return l.front();
        }
        ++it;
    }
    auto ret = l.begin();
    while (it!=l.end()) {
        ++it;
        ++ret;
    }
    return *ret;
}

void display(forward_list<T> lst)
{
    
    for(typename forward_list<T>::iterator start = lst.begin(); start != lst.end() ; ++start)
    {
        cout << *start << " ";
    }
    
    cout << endl;
}

void insereInfoAtPosit(forward_list<T1>& maListeOriginale, int laPosition, T2 nouvelleInfo) throw (PrecondVioleeExcep) {
    // version itérative
    // itérateur positionné sur la postion avant le premier élément de la liste
    //  -> il faut être sur le précédent de laPosition pour fair l'insertion après !!
    auto it = maListeOriginale.before_begin();
    int positionCourante = 1;
    // tantque l'on a pas atteint laPosition et que l'on est pas à la fin de la liste
    while ((positionCourante < laPosition) && (it != maListeOriginale.end())) {
        positionCourante++;
        // avancer dans la liste sur l'itérateur
        ++it;
    }
    if (it != maListeOriginale.end()) { // si on a accès à laPosition
        // insérer après l'élément pointé par l'itérateur
        it = maListeOriginale.insert_after(it, nouvelleInfo);
    } else { // sinon on lève une exception
        throw PrecondVioleeExcep("Insertion imposible à l'indice " + to_string(laPosition));
    }
}

void remove_evens_and_double_odds(forward_list<int>& data) {
    for (auto cur = data.begin(), prev = data.before_begin(); cur != data.end(); ) {
        if (*cur & 0x1)
            cur = data.insert_after(prev, *cur),
            advance(prev, 2),
            advance(cur, 2);
        else
            cur = data.erase_after(prev);
    }
}