ATL / WTL / STL

ekimpl wrote:

'find' isn't of much use in my case, since it only returns first match.

bool FindNumber(const std::vector<sStringStruct>&v, const std::string& nString)
{
	bool found = false;
	typedef std::vector<sStringStruct> t_vec;
	sStringStruct searched_string = sStringStruct(nString);
	t_vec::const_iterator i = std::find(v.begin(), v.end(), searched_string);

	// Check if got a first match
	while(i != v.end())
	{
		// We found a match!
		found = true;

		// Print the match and search again but not the whole vector!
		// Search only in the remeaning unsearched range.
		std::cout<<"MATCH:"<<(*i).m_nString << std::endl;
		i = std::find(i+1, v.end(), searched_string);	
	}
	
	// Say if we found something or not
	return found;
}

ekimpl wrote:

Now that I see Your solution I don't know if I understand the concept of iterators correctly.

ekimpl wrote:

I thought that t_vec::const_iterator i = std::find(v.begin(), v.end(), searched_string) would result in i pointing only to the matches

ekimpl wrote:

So if I wanted to know all the indexes of found matches outside of FindNumber, it should return an array of found indexes, yes ?

bool FindNumber(const std::vector<sStringStruct>&v, const std::string& nString, std::vector<int>& indexes)
{
	bool found = false;
	sStringStruct searched_string = sStringStruct(nString);
	
	const int vec_size = v.size();
	for(int i = 0; i < vec_size; i++)
	{
		if(v[i] == searched_string)
		{
			indexes.push_back(i);
			found = true;
		}
	}
	
	// Say if we found something or not
	return found;
}

        // And you can use the function this way:
        std::vector <sStringStruct> vec;
        vec.push_back(sStringStruct("xxxx"));
	vec.push_back(sStringStruct("aaaa"));
	vec.push_back(sStringStruct("bbbb"));
	vec.push_back(sStringStruct("cccc"));
	vec.push_back(sStringStruct("aaaa"));

	std::vector<int> indexes;
	bool found = FindNumber(vec, "aaaa", indexes);
	if(found)
	{
		const int indexes_size = indexes.size();
		for(int i = 0; i < indexes_size; i++)
		{
			std::cout << "MATCH:" << vec[indexes[i]].m_nString << std::endl;
		}
	}

#include <algorithm>

#include <functional>

#include <iomanip>

#include <iostream>

#include <map>

#include <string>

#include <utility>

#include <vector>

 

using namespace std;

 

class PC

{

public:

            enum PC_type { Dell, HP, IBM, Compaq };

            

            PC( PC_type appliance = Dell, int model = 220,

                        int serial = 0 );

            

            bool operator<( const PC& rhs ) const;

            

            PC_type appliance() const;

            int model() const;

            string name() const;

            

            void print() const;

            

            int serial() const;

            

private:

            PC_type appliance_;

            int model_;

            int serial_;

            

};

ashtwin wrote:

Thanks for replying. I am using VS98(VC6.0)

template std::pair<PC::PC_type,PC> std::make_pair<PC::PC_type,PC>(PC::PC_type,PC);

int main( )
{
   // Rest of your code

template std::pair<PC::PC_type,PC> std::make_pair<PC::PC_type,PC>(PC::PC_type,PC);
int main( ){

pair<PC::PC_type, PC> MyFunction(PC::PC_type pcType, PC pc)
{
  return make_pair(pcType, pc);
}
transform( kind, kind+num_appliances, v.begin(),inserter( stock, stock.end() ),MyFunction);