aus einem String sollen alle Duplikate entfernt werden.
z.b.

string array[4]={"IBM","Amazon","IBM","Google"};

Hättet ihr das auch so programmiert ? Ist diese Lösung die funktioniert auch brauchbar hinsichtlich Performance etc. ?

int removeDuplicates( string  array [], int len)
{
	for(int i= 0 ; i< len ; i++)
	{
		for(int j =i+1 ; j<len;j++)
		{
			if ( array[i].compare(array[j]) == 0 ) 
			{
				for(int k = j ; k <len-1 ; k++)
				{
					array[k] = array[k+1]; 

				}
				len--;
			}
		}

    }
	return len; // neue Laenge des array. 
}

Ansonsten:

std:sort,
std::unique,
(std::vector::erase)<<würdest du die Elemente am Ende wirklich löschen...

in der Reihenfolge.

Hättet ihr das auch so programmiert ?

Definitiv nicht: http://www.cplusplus.com/reference/algorithm/unique/

Also erst std::sort, dann std::unique. Wenn die Reihenfolge erhaltenbleiben soll, arbeitet man auf Indexmengen.

Klar die Reihenfolge soll schon gleich bleiben. WEnn du sortierst ist das nicht mehr der Fall.

Trotzdem ist das kein Grund, auf grundlegenden Komfort und auch grundlegende Abstraktion zu verzichten. So sollte die Signatur aussehen:

template <typename Iterator> Iterator removeDuplicates(Iterator begin, Iterator end);  // Rückgabewert a la vector::erase

Zack! Schon ist egal, ob es sich um string, Zahlen oder sonstwas handelt. Schon ist es sich egal, ob diese in einem Array, vector oder selbstgeschriebenen Container sind. Trotzdem bleibt der Code fast identisch. So viele Vorteile, kein Nachteil.

Eine Liste (vector, array oder oder) erzeugen, der alle Indizes trägt, diesen sortieren, "uniquen" und Duplikate removen, indem per Prädikat auf das Element an der Stelle x zugegriffen wird?

Also so etwa?!

int main()
{
  vector<string> producers = { "IBM",  "Dell",  "Intel",  "Amazon",  "IBM" };
  vector<size_t> indizes = {0,  1,  2,  3,  4};             // ja geht besser mit generate/fill oder oder

  sort(indizes.begin(), indizes.end(), 
    [&](size_t a, size_t b)
    {
      return producers[a] < producers[b];
    }
  );

  indizes.erase(
    unique(indizes.begin(),  indizes.end(), 
      [&](size_t a,  size_t b)
	{
	  return producers[a] == producers[b];
	}
      ), 
    indizes.end()
  );

  vector<string> results;                                   // geht auch schöner
  results.reserve(indizes.size());
  for (auto i : indizes)
    results.push_back(producers[i]);

  return 0x0;
};

Klar die Reihenfolge soll schon gleich bleiben. WEnn du sortierst ist das nicht mehr der Fall.

Und nochmal, arbeite mit Indexmengen.