Exe darf man nicht umbenennen

Hallo!
Wie kann man in C++ eine exe schreiben, die man nicht umbennen darf? Wenn man sie umbennent läuft sie halt nicht... So würde ich das gerne machen, aber wie?

HumeSikkins

Hallo,
mit Standard-C++ geht das nicht. Unter Windows könntest du z.B. die API-Funktion
GetModuleFileName verwenden und das Ergebnis mit dem gewünschten Namen vergleichen.

Danke schön
Habe mir schon gedacht, weil ich davon in meinen knapp 1000 Seiten Buch nichts davon gelesen habe

ist nicht immer der erste parameter von argc der dateinamen der exe?

Habe ich schon probiert aber das klappt nicht

thordk

in argv[0] steht der name der datei, die aufgerufen wurde.

Julian__

ja, du koenntest z.B. sowas machen:

#include <string>

bool rightFileName( char *filePath );

int main( int argc, char **argv )
{
	if( !rightFileName( argv[ 0 ] ) )
		return 1;
	// weiterer programmablauf ...
}

bool rightFileName( char *filePath )
{
	std::string reversed;
	for( int i = strlen( filePath ) - 1; i >= 0; i-- )
		if( filePath[ i ] == '\\' )
		{
			if( reversed != "" )
				break;
		}
		else
			reversed += filePath[ i ];
	std::string fileName;
	for( int i = reversed.length() - 1; i >= 0; i-- )
		fileName += reversed.at ( i );
	if( fileName == "erforderter_dateiname.exe" )
		return true;
	else
		return false;
}

wahrscheinlich nicht besonders performant, auch nicht getestet aber ich glaube so sollte es funktionieren.

mfg,
julian

Funktioniert wunderbar
Danke

lolz

Julian__ schrieb:

ja, du koenntest z.B. sowas machen:

#include <string>

bool rightFileName( char *filePath );

int main( int argc, char **argv )
{
	if( !rightFileName( argv[ 0 ] ) )
		return 1;
	// weiterer programmablauf ...
}

bool rightFileName( char *filePath )
{
	std::string reversed;
	for( int i = strlen( filePath ) - 1; i >= 0; i-- )
		if( filePath[ i ] == '\\' )
		{
			if( reversed != "" )
				break;
		}
		else
			reversed += filePath[ i ];
	std::string fileName;
	for( int i = reversed.length() - 1; i >= 0; i-- )
		fileName += reversed.at ( i );
	if( fileName == "erforderter_dateiname.exe" )
		return true;
	else
		return false;
}

wahrscheinlich nicht besonders performant, auch nicht getestet aber ich glaube so sollte es funktionieren.

mfg,
julian

Mein Vorschlag:

//#include <string>
//#include <algorithm>

bool rightFileName( const std::string& filePath, const std::string& appName )
{
	std::string::size_type beg( filePath.find_last_of( "\\/" ) );

	//falls kein slash gefunden wurde, nehmen wir an, 
	//dass in filePath nur der Name steht
	if( beg == std::string::npos )
	{
		return filePath == appName;
	}
	else
	{
		//Die Länge wird von dem kürzeren String übernommen
		std::string::size_type len( std::min( appName.size(), 
									filePath.size() - beg - 2 ) );

		//Sieht wild aus, ruft aber nur die compare Funktion der char_traits von std::string auf
		return std::string::traits_type::compare( filePath.c_str() + beg + 1,
												appName.c_str(), len ) == 0;
	}
}

thordk

ist doch gar nicht nötig, irgendwelche sonderzeichen im string zu suchen.

bool rightFileName( char *filePath ) {
    std::string rightName = "sosollsieheissen.exe";
    int length = strlen(filePath);

    if(length < rightName.length()) // theoretisch möglich
        return 0;

    return rightName.compare(length - rightName.length(), rightName.length(), filePath) == 0;
}

Julian__

stimmt ... so gehts auch wunderbar.
warum bin ich da nicht drauf gekommen? ich sollte mehr schlafen ...

mfg,
julian

lolz

thordk schrieb:

ist doch gar nicht nötig, irgendwelche sonderzeichen im string zu suchen.

Ich hätt mir mal besser die Doku zu basic_string::compare angeschaut

Krux

da es hier ja noch nicht genugLösungen gibt, hier mal meine:

#include <iostream>
#include <string>

using namespace std;

int main(int argc, char** argv) {

    string s1 = "name.exe";
    char *iter1,*iter2;

    iter1 = iter2 = argv[0];

    while(*iter1 != '\0')
        if (*iter1++ == '\\') // unter linux müsste hier '/' sein 
            iter2 = iter1;

    cout << boolalpha << (s1 == iter2) << endl;
    return 0;
}

ich find die lösung erwähnenswert, weil man so schön mit dem opterator == vergleichen kann, unabhängig davon, ob das eine nun ein char* ist oder nicht.