ich hab hier im Forum mal gelesen, dass man es in der Regel
so macht, dass der Speicher von dem freigegeben wurde, der ihn
angefordert hat. Jetzt hab ich nen kleinen HttpClient geschrieben,
der in etwa so arbeiten soll, dass ich sage:

std::vector<std::pair<char*, char*>>* getHeader();

Jetzt könnte ich zwar einen vector an die Methode übergeben,
aber die char* müßte ich dann ja immernoch von dem Teil
des Programms löschen lassen, der ihn nicht angefordert hat.

Wie würdet ihr das machen?
Hilft mir ja evtl. etwas wie std::auto_ptr weiter?
Damit hab ich mich noch nicht beschäftigt, werde ich aber jetzt
machen.

Gruß,
*Cpp-Anfänger*

Muss ihn also freigeben

grüße

Erst soll der Header eingelesen werden:

void MyClass::readHeader(){
void* response  = readResponse(); // Lies den Response (Zeichenkette) in void*
boolean eoh = false; // end of header
void* linebegin = response;
this->header = new std::vector<std::pair*<char*, char*>>();
while(!eoh){
    void* endofline = findEndOfLine(linebegin);
    void* delimiter = findDelimiter(linebegin);
    char* key =  (char*)malloc(delimiter-linebegin);
    char* value =  (char*)malloc(endofline-delimiter);
    // Kopiere Inhalte in key und value (mit abschließender '\0')
    std::pair* pair = new std::pair(key, value);
    header->add(pair);
    // Prüfe end of header
}
}

und später nur noch

std::vector<std::pair*<char*, char*>> MyClass::getHeader(){
    return header
}

Gruß,
*Cpp-Anfänger*

Würde std::string irgendwas ändern?

Ja, es würde eben Dein Problem komplett aus der Welt schaffen, weil std::string intern automatisch für die korrekte Reservierung und Freigabe von Speicher sorgt.

struct free_deleter
{
  void operator()( void* p ) { std::free(p); }
};

Wann wird denn operator() aufgerufen?

wenn das so einfach ist