CODEWITHSUNDEEP
c++algorithmgraphgraph-algorithm
user3109069
user3109069

Reputation:

Passing Vector to function while using Graph

I wrote my code like this inside a class to calculate max distance from source to node. Now I need to take it out of the class and have a similar function to calculate my distances but by using Djikstra. So, I would need to pass this city vector and source being one of my vertex ( this will loop over vertices ) and return a distance from this function back to class for my next computation. I am running out of time so help me.

int distanceToNearCity(int cityIdOfStore, const std::vector<City> & AllCities) const
{
  // is there a store in this city ?
  if (storeExists || cityId == cityIdOfProposedNewStore)
  {
     return 0; // 0 distance
  }

  int distance = TOOFAR; // initialise with more than max allowed
  for (int i=0; i<connectingCities.size(); ++i)
  {
     int id = connectingCities[i];
     if (AllCities[id-1].hasStore() || AllCities[id-1].getId() == cityIdOfProposedNewStore)
     {
       // we have a store (or proposed one) here, but is it's distance more than other stores ?
       if (distances[i] < distance)
       {
          distance = distances[i];
       }
     }
  }

  return distance;
}

How can I pass these class objects to function which is public.Thanks!!

Upvotes: 1

Views: 179

Answers (1)

dousin
dousin

Reputation: 526

Well, accessing internal member variables from main is problably a bad design, breaks encapsulation, is a possible source of problems, thus not a good idea.

Solution 1

Let's say your class is called MyOriginal. Make distanceToNearCity virtual. Create a derived class MyDerived and rewrite distanceToNearCity so that implements Djikstra. In the derived class you can access the original member variables from MyOriginal, as long as they are public or protected. The user (main) does not need to know the implementation details.

Solution 2

Rewrite the original distanceToNearCity method so, that it has no side effects as it ware a static method. This means that it does not need access to any of the member variables. Pass all arguments to the method via parameters. I mentioned 'as it was a static method', since the method will not be the member of the original MyOriginal class. Make MyOriginal a template class, implement distanceToNearCity in an external class and pass this class as a template argument to MyOriginal. As a non member, you can implement any number of distance algorithms and pass them to the original class. This solution has the advantage, that the call to the 'virtual' method is known at the compile time, so it produces faster code.

template<class T> // T will contain distance computation
class MyOriginal
{
public:
  void process()
  {
    .. // your staff
    int distance = T::distanceToNearCity(necessary arguments); // call the external implementation
    .. // rest of your staff
  }
};
class OriginalDistance
{
public: 
  static int distanceToNearCity(necessary arguments); // your original implementation
};
class DjikstraDistance
{
public: 
  static int distanceToNearCity(necessary arguments); // another distance computation
};

int main(int argc, char *argv[])
{
  MyOriginal<DjikstraDistance> myInstance;
  myInstance.process(); // call processing, use DjikstraDistance::distanceToNearCity() inside
}

Solution 3

If you from some reason dislike both previous implementations, you can use a 'c' style solution. Create a type which represents a signature of the distanceToNearCity method. Write 'distanceToNearCityOriginal' and 'distanceToNearCityDjikstra' functions. Pass a pointer to desired function as a paramter the MyOriginal::process method. C++ developers will dislike you.

typedef int (DistanceAlgo*)(necessary arguments); // pointer to a function which returns int
int distanceToNearCityOriginal(necessary arguments); // first implementation of distance
int distanceToNearCityDjikstra(necessary arguments); // second implementation of distance
class MyOriginal
{
public:
  void process(DistanceAlgo algo)
  {
    .. // your staff
    int distance = (*algo)(necessary arguments); // call the external implementation
    .. // rest of your staff
  }
};
int main(int argc, char *argv[])
{
  DistanceAlgo algo = &distanceToNearCityDjikstra; // choose djikstra
  MyOriginal myInstance;
  myInstance.process(algo); // call processing, use distanceToNearCityDjikstra inside
}

Upvotes: 2

Related Questions