class test
{
   GrosserDatentypMitAufwändigemKopierkonstruktor array[SehrGrosseZahl];
};

Einfach zeiger tauschen geht hier ja nicht. Ich muss hier eine effiziente swap funktion für die Klasse "test" schreiben, die ich zur Verfügung gestellt bekommen habe und nicht ändern kann.
Gibt es dabei eine "Standard" Vorgehensweise?

Wenn das nicht schnell genug ist oder du die Klasse test ändern darfst, würde ich die folgendes empfehlen:

class test
{
   vector<GrosserDatentypMitAufwändigemKopierkonstruktor> array;
   ...
public:
   ...

   friend void swap(test & a, test & b) {
      a.array.swap(b.array);
      ...
   }
};

Gruß,
SP

Das einzige, was du machen kannst, ist die Klasse test dynamisch anzulegen und somit deren Zeiger zu tauschen. Ich empfehle eine Wrapper-Klasse:

class test_wrapper
{
	public:
		test_wrapper()
		: m_test(new test())
		{
		}

		test_wrapper(const test_wrapper& origin)
		: m_test(new test(*origin.m_test))
		{
		}

		test_wrapper::~test_wrapper()
		{
			delete m_test;
		}

		test_wrapper& operator= (const test_wrapper& other)
		{
			test_wrapper tmp(other);
			swap(tmp);
		}

		void swap(test_wrapper& other)
		{
			std::swap(m_test, other.m_test);
		}

		// hier zusätzlich Schnittstelle von test
		// bereitstellen und Aufrufe an m_test weiterleiten

	private:
		test* m_test;
};

Auf die Idee, WIN32_FIND_DATA einfach dynamisch in meiner Klasse anzulegen, bin ich garnicht gekommen. Ich muss mal ausprobieren, ob sich dadurch ein geschwindigkeitsvorteil ergibt

class test
{
    WIN32_FIND_DATA* p;
};
inline void swap(test& a, test& b)
{
    WIN32_FIND_DATA* tmp = a.p;
    a.p = b.p
    b.p = tmp;
}

class test
{
    WIN32_FIND_DATA* p;
};
inline void swap(test& a, test& b)
{
    WIN32_FIND_DATA* tmp = a.p;
    a.p = b.p
    b.p = tmp;
}

Das würde ich aber die Klasse selbst übernehmen lassen, um die Kapselung zu erhalten (siehe mein oberes Beispiel). Von aussen kannst du immer noch eine globale swap() -Funktion bereitstellen:

void swap(test_wrapper& lhs, test_wrapper& rhs)
{
    lhs.swap(rhs);
}