[slahn]

Da aber diese erste "bat" eh zu einer "exe" werden soll ist der obere Code etwas unnötig und man sollte sich auch nicht zu lange damit aufhalten, diesen auszubessern ...

Hier ist eine Referenzimplementierung in C von mir ... die erstellte "bat" heißt bei mir jedoch genau so wie die "exe" nur mit ".bat" angehängt und befindet sich immer im gleichen Ordner wie die "exe" (es ist wichtig dass die "exe" aufgerufen wird und nicht eine Verknüpfung davon, da sonst die Verknüpfung gelöscht wird)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void doSomething()
{
    // Darunter könnte ihr Code stehen ...

    // Darüber könnte ihr Code stehen ...
}

char* getBatName(char const *name)
{
    /*
     * Erstelle genügend Speicher für den kompletten Pfad und Namen von diesem
     * Programm + ".bat" ('\0' kommt auch dazu)
     *
     * argv[0] enthält den kompletten Pfad von diesem Programm (+ Dateiname)
     */
    char *batName = (char*) malloc(strlen(name)+5);

    if(batName == NULL)
    {
        /*
         * konnte keinen speicher bereitstellen
         */
        perror("ERROR (malloc)");
        return NULL;
    }

    /*
     * neuen Dateinamen für die "*.bat" basteln.
     * Voller Pfad von diesem Programm (+ Dateiname) und anhängen von ".bat"
     */
    strcpy(batName, name);
    strcat(batName, ".bat");

    return batName;
}

// gibt Verantwortung über Speicher des "*.bat"-Namen an den Aufrufer weiter.
char* createBat(char const *name)
{
    char *batName = getBatName(name);

    if(batName == NULL)
    {
        /*
         * konnte Datei Namen für "*.bat" nicht erzeugen
         */
         return NULL;
    }

    FILE *pFile = fopen(batName, "w");

    if(pFile == NULL)
    {
        /*
         * konnte Datei nicht öffnen
         */
        perror("ERROR (fopen)");
        return NULL;
    }

    /*
     * neue "*.bat" erstellen.
     * löscht zuerst die "*.exe" (den Ersteller, dieses Programm) und danach
     * sich selbst (die hier erstellte "*.bat").
     *
     * !!! Wichtig !!!!
     * Beim löschen von sich selbst, wird "gleichzeitig" "exit 0" ausgeführt, da
     * durch "start" (siehe execCommand) eine neue "cmd" gestartet wird und
     * durch das löschen der Befehl danach nicht mehr ausführbar wäre.
     */
    fputs("@echo off\n"
          "del ", pFile);
    fputs(name, pFile);
    fputs("\n"
          "del %0 && exit 0", pFile);

    fclose(pFile);

    // gibt Verantwortung über Speicher des "*.bat"-Namen an den Aufrufer weiter
    return batName;
}

int execBat(char const *name)
{
    /*
     * Erstelle genügend Speicher für "start " + den kompletten Pfad und Namen
     * von der "*.bat" ('\0' kommt auch dazu)
     *
     * "start [name]"
     */
    char *execCommand = (char*) malloc(strlen(name)+8);

    if(execCommand == NULL)
    {
        /*
         * konnte keinen speicher bereitstellen
         */
        perror("ERROR (malloc)");
        return -1;
    }

    /*
     * Befehl zu starten (erstellt eine neue "cmd") der "*.bat".
     * "start " + Voller Pfad von diesem Programm (+ Dateiname) und anhängen von ".bat"
     */
    strcpy(execCommand, "start ");
    strcat(execCommand, name);

    // "start [name]" ausführen
    system(execCommand);

    free(execCommand);

    return 0;
}

int main(int argc, char const *argv[])
{
    /*
     * In die Funktion sollte noch Code rein ...
     * z.B. das anzeigen eines Textes ...
     */
    doSomething();

    /*
     * "*.bat" erstellen.
     * bekomme verantwortung für Speicher im Rückgabewert.
     */
    char *batName = createBat(argv[0]);

    if(batName == NULL)
    {
        // konnte "*.bat" nicht erstellen
        return -1;
    }

    if(execBat(batName) != 0)
    {
        // konnte "*.bat" nicht ausführen
        return -2;
    }

    free(batName);

    return 0;
}