Wie geht die Wertübergabe eines char name[] an die Main Funktion?

Hallo an alle,

ich habe mal versucht nummerierte Dateinamen zu erstellen. Das funktioniert auch ganz gut soweit.

Nun habe ich nur noch das Problem wie ich in der Main auf diesen "namen" zugreigen kann um ihn zu verwenden, z.B. beim erstellen von neuen Dateien.

Habe schon einiges versucht, aber ich blicke es irgendwie ned:(

Kann mir jm. geschwind helfen?

Danke und Grüße

Fill

using namespace std;

void dateiname (int &i);

int main (void)
{

	int i=0;
	int a=0;

	for(a=0; a<10; a++)
	{
		i++;
		dateiname (i);
		cout << i << endl;
//		cout << ??name?? << endl;		//Wie bekomme ich aus der Funktion "dateiname" das name in der Main visualisiert?
	}									// wie geht der Zugriff?
		return 0;
}

void dateiname (int &i)
{
	char name[80];

	sprintf( name, "%d.txt", i ); 
}

knivil

1.) Deine Funktion braucht einen Rueckgabewert oder du musst globale Variablen benutzen.
2.) Es empfielt sich, std::string zu benutzen!
3.) Fuer Grundlagenwissen eignen sich Buecher.

1.) Über eine globale Variable wollte ich es nicht machen. Das ich einen Rückgabewert benötige war mir bewusst (sorry das ich das nicht kenntlich gemacht habe.)

3.) Was hilfreich wäre als ein Buch zu empfehlen, da man dies ja meist schon hat und nicht fündig wird, eher den Bereich nachdem man suchen muss, da man bei so Todschlägern erstmal das Richtige finden muss, wenn man nicht weiß nach was man suchen muss.

Nun gut...

Ist es empfehlenswert einen Zeiger zurückzugeben und da es ja dynamisch ist, mit new und delete zu arbeiten?

2.) Danke für den hinweis ich werde dannach schauen..

grüße

Belli

#include <string>

...

string dateiname (int &i)
{
    char name[80];

    sprintf( name, "%d.txt", i );
    string ret(name);
    return ret;
}

knivil

oder einfach:

std::string dateiname = std::to_string(i)+".txt";

Ist es empfehlenswert einen Zeiger zurückzugeben und da es ja dynamisch ist, mit new und delete zu arbeiten?

Nein, Zeiger werden in C++ nur sehr selten gebraucht.

_matze

FillColin schrieb:

Ist es empfehlenswert einen Zeiger zurückzugeben und da es ja dynamisch ist, mit new und delete zu arbeiten?

Nein, absolut nicht, da du mit new allokierten Speicher ja auch freigeben musst. Wo machst du das dann? Überlässt du das der aufrufenden Stelle, so wie hier?

char *name=dateiname(i);
//...
delete[] name;

Unschön und gefährlich. Wenn du (oder ein anderer!) die Funktion nach einiger Zeit wieder verwendest, weißt du u.U. gar nicht mehr, dass du hier auch wieder Speicher freigeben musst => Speicherleck.

Machst du eine Extra-Funktion zum Aufräumen und bietest die beiden dann quasi als Paar an, so wie hier?

char *name=dateiname_new(i);
//...
dateiname_delete();

Unschön und unnötig. Von einer Funktion, die nur einen Dateinamen generieren soll, erwartet man, dass sie unkompliziert ist. Das hier ist Overkill.

Nimm einfach std::string, dann hast du keine Sorgen mehr in der Richtung. Die Klasse übernimmt das Speicher-Management für dich, du kannst sie problemlos aus Funktionen zurückgeben usw. Ein Beispiel hab es ja schon von Belli.

Gang und gäbe ist, einen Puffer zu füllen, den der Benutzer angibt...Gang und gäbe in C jedenfalls.

#include <iostream>
#include <cstdio>

void dateiname (char* buf, std::size_t size, int i){
  std::snprintf( buf, size, "%d.txt", i );
}

int main(){
  const std::size_t size = 80;
  char buf[size];
  dateiname(buf, size, 42);
  std::cout << buf << '\n';
}

Das sieht häßlich aus und ist auch ungewohnt für C++ Programmierer.
Ich schließe mich daher meinen Vorrednern, die Dir std::string empfehlen...

PS: Der Gipfel:

// :(
const char* dateiname(int i)
{
  static char buf[80];
  std::snprintf( buf, 80, "%d.txt", i );
  return buf;
}

_matze

knivil schrieb:

oder einfach:

std::string dateiname = std::to_string(i)+".txt";

Ergänzung: to_string gibt's aber erst ab C++11. Eine Alternative wäre boost::lexical_cast.

Herzlichen Dank an alle für die Antworten und die Hinweise, wie man es auf jedenfall nicht machen soll..

grüße

auch für std__string! schrieb:

void dateiname (char* buf, std::size_t size, int i){
  std::snprintf( buf, size, "%d.txt", i );
}

int main(){
  const std::size_t size = 80;
  char buf[size];
  dateiname(buf, size, 42);
  std::cout << buf << '\n';
}
Das sieht häßlich aus und ist auch ungewohnt für C++ Programmierer.
Ich schließe mich daher meinen Vorrednern, die Dir std::string empfehlen...

Hey vorsichig Brauner, du willst wohl einen FlameWar anzetteln!
Aber recht hast du, das ganze std:: Zeug macht den ~~Code~~ Kot hässlich.

FillColin schrieb:

Herzlichen Dank an alle für die Antworten und die Hinweise, wie man es auf jedenfall nicht machen soll..

grüße

hast du nicht bellis brauchbaren ansatz gesehen?
das kann man noch ein bisschen universeller einsetzbar und sicherer machen, indem man snprintf benutzt:

string numbered_filename ( string name, string ext, unsigned number)
{    
	char number_buf[256]={0};
    snprintf( number_buf, sizeof(number_buf), "%u", number );
    string ret(name+number_buf+"."+ext);
    return ret;
} 

int main(void)
{ 
	string fname = "path", ext = "txt", result;
	result = numbered_filename(fname, ext, 88);
	cout << result << endl;
	return 0;
}

habe da nochmal eine Frage

Ich will nun die Dateien mit einem Zeitstempel versehen und habe volgendes gemacht

#include "stdafx.h"
#include <string>
#include <ctime>		// Dateinamengenerierung
#include <iostream>		// Dateinamengenerierung
//#include <algorithm>	// copy 
//#include <iterator>		// i(o)stream_iterator 
//#include <string>
//#include <iostream> 
//#include <fstream> 
//#include <limits>		// numeric_limits 
//#include <time.h>		// Für wait-Funktion

using namespace std;

string dateiname ();

int main (void)
{

	int a=0;

	time_t result = time(NULL);
	string ret_name = asctime(localtime(&result));

	cout << ret_name << endl;

	for(a=0; a<10; a++)
	{
		ret_name=dateiname ();
		cout << ret_name << endl;		
		getchar();		
	}			

		return 0;
}

string dateiname ()
{
	char name[80];

	time_t result = time(NULL);
	string date = asctime(localtime(&result));

	cout << date;

	sprintf( name, "%s.txt", date); 
    string ret(name); 
    return ret; 
}

Bei Zeile 46 funktioniert irgendwas nicht und ich habe kein plan was da schiefgeht. Hätte gerne den erzeugten Zeitstempel als Dateiname.

KAnn mir da jm. ein tip geben?

danke u grüße

daddy_felix

warum das char Array? erstelle dir doch gleich einen string...

std::string name = date + ".txt";

gute Frage warum eigentlich ein array

string dateiname ()
{

	time_t result = time(NULL);
	string date = asctime(localtime(&result));

	string name = date+".txt";

	return name; 
}

nun habe ich in der ausgabe noch nen zeilenumbruch drinne..ist das normal oder bekomme ich den irgendwie weg?

kein plan

_______
weil weiter im programm wollte ich dann sowas in der art machen

ofstream f2(ret_name);

aber nun legt er kein neues txt an:(

hm....

#include "stdafx.h"
#include <string>
#include <ctime>		// Dateinamengenerierung
#include <iostream>		// Dateinamengenerierung
#include <algorithm>	// copy 
#include <iterator>		// i(o)stream_iterator 
#include <string>
#include <iostream> 
#include <fstream> 
#include <limits>		// numeric_limits 
#include <time.h>		// Für wait-Funktion

using namespace std;
using namespace System;

string dateiname ();

int main (void)
{

	time_t result = time(NULL);
	string ret_name = asctime(localtime(&result));

	cout << ret_name << endl;

		ret_name=dateiname ();
		cout << ret_name << endl;		

			ifstream f1("test.txt");					// vorhanden
			ofstream f2(ret_name);						// neuanlegen
//			copy();
			f1.close();									// Schließen
			f2.close();									// Schließen
			getchar();
	return 0;
}

string dateiname ()
{

	time_t result = time(NULL);
	string date = asctime(localtime(&result));

	string name = date+".txt";

	return name; 
}