Re: incomplete type error - function object

    I get a compilation error "parameter 2 of `Clusters
sorted(Clusters, func_obj)' has incomplete type `func_obj' " when
attempting to compile the following code:

                     some_clusters =
sorted(some_clusters,less_Eccentricity());

 I`m trying to pass a function object (less_Eccentricity) into a
higher level function that uses it in the call to sort.

    What is wrong with the use of the function object in the call
here? Also, below you will find some other code that compiled fine.
Am I missing something?

                                                Thanks, Alan

Does Not Compile:

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <vector>
#include <string>
#include <math.h>
#include <stdexcept>

using namespace std;

struct measurement
{
   string character;
   string filename;
   int Num_Regions;
   int Euler_Number;
   double Eccentricity;
};

typedef vector <measurement> Measurements;

struct cluster
{
   double max;
   double min;
   Measurements measurements;
};

typedef vector <cluster> Clusters;

class less_Eccentricity : binary_function<measurement, measurement,
bool>
{
  public:
       result_type operator() (const measurement& a, const
measurement& b)
           {
               return a.Eccentricity < b.Eccentricity;
           }
};

Clusters sorted(Clusters cluster_vector, class func_obj);

int main(int argc, char *argv[])
{

   measurement data;
   Measurements measurements;
   cluster a_cluster;
   Clusters some_clusters;

   some_clusters = sorted(some_clusters,less_Eccentricity());

   return EXIT_SUCCESS;
}

template <class T1>
Clusters sorted(Clusters cluster_vector, T1 func_obj)
{
 for (int i = 0; i < cluster_vector.size(); i++)
   {
     for (int j = i + 1; j < cluster_vector.size(); j++)
           if (cluster_vector[i].min > cluster_vector[j].min)
               {
                   // swap structures
                   swap(cluster_vector[i],cluster_vector[j]);
               }
           else if (cluster_vector[i].min == cluster_vector[j].min)
                   if (cluster_vector[i].max < cluster_vector[j].max)
                       {
                           swap(cluster_vector[i],cluster_vector[j]);
                       }

sort(cluster_vector[i].measurements.begin(),cluster_vector[i].measurements.end(),func_obj);
   }
   return cluster_vector;
}

Compiles Fine:

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector>

using namespace std;

class measurement
   {
     public:
       double metric1, metric2, metric3;
   };

typedef vector<measurement> cluster;
typedef vector<cluster> Clusters;

class less_metric1 : binary_function<measurement, measurement, bool>
{
 public:
   result_type operator()(const measurement& a, const measurement& b)
       {
           return a.metric1 < b.metric1;
       }
};

class less_metric2 : binary_function<measurement, measurement, bool>
{
 public:
   result_type operator()(const measurement& a, const measurement& b)
       {
           return a.metric2 < b.metric2;
       }
};

class less_metric3 : binary_function<measurement, measurement, bool>
{
 public:
   result_type operator()(const measurement& a, const measurement& b)
       {
           return a.metric3 < b.metric3;
       }
};

template <class T>
Clusters sorted_Clusters (Clusters Clusters_list, T func_obj)
{
   for (int i = 0; i < Clusters_list.size(); i++)
       {
        for (int j = i + 1; j < Clusters_list.size(); j++)
           {
               // do some stuff
           }

sort(Clusters_list[i].begin(),Clusters_list[i].end(),func_obj);
   }
   return Clusters_list;
}

template <class T>
void some_function (T in)
{
}

int main()
{
   // Create objects
   measurement data1, data2, data3, data4;
   data1.metric1 = 1; data1.metric2 = 2; data1.metric3 = 3;
   data2.metric1 = 2; data2.metric2 = 3; data2.metric3 = 2;
   data3.metric1 = 3; data3.metric2 = 1; data3.metric3 = 1;
   data4.metric1 = 4; data4.metric2 = 4; data4.metric3 = 4;
   // put them into a vector of 2 clusters
   cluster a_cluster;
   Clusters some_clusters;
   a_cluster.push_back(data1);
   a_cluster.push_back(data2);
   some_clusters.push_back(a_cluster);
   a_cluster.clear();
// some_clusters.clear();
   a_cluster.push_back(data3);
  some_clusters.push_back(a_cluster);
   a_cluster.push_back(data4);
   some_clusters.push_back(a_cluster);
   a_cluster.clear();

   // Sort cluster data for each cluster
   some_clusters = sorted_Clusters(some_clusters,less_metric1());

   // Print out results
   for (int i = 0; i < some_clusters.size(); i++)
       {
           cout << "Cluster " << i << "\n";
           for (int j = 0; j < some_clusters[i].size(); j++)
               cout << " " << (some_clusters[i])[j].metric1 <<
"\n";
       }

   system("PAUSE");
}