char *std_argv[]={"A", "B"};
char *std_argv2[]={"bla", "..."};//(soll später auch eingefügt werden)
char*argv[sizeof(std_argv)+sizeof(std_argv2)+2]; //+2 einfach ignorieren ;-)
...
for(int arg=0; arg < (sizeof(std_argv)); arg++){
[b]strncpy(argv[arg],std_argv[arg],sizeof(argv[arg]-1));[/b] //in dieser Zeile kommt die ausgabe: [b]Segmentation fault[/b]
}

Anscheined benutze ich strncpy falsch?

Danke für Hilfe

Oder:

Du machst das was du vor hast nicht mit char-Arrays, sondern wie es sich gehört mit std::string. Dazu ist die Klasse ja schließlich gemacht.

Die Größe eines char* Arrays ist die Größe eines char* mal die Anzahl der Elemente. Auf welche Strings die Zeiger zeigen ist dabei völlig irrellevant. Da musst du mit strlen arbeiten um den benötigten Speicher richtig zu berechnen.

Oh
Hab es so umgeändert:

strncpy(argv[arg],std_argv[arg],strlen(argv[arg]-1));

Kommt aber das gleiche dabei raus

SeppJ schrieb:

Du machst das was du vor hast nicht mit char-Arrays, sondern wie es sich gehört mit std::string. Dazu ist die Klasse ja schließlich gemacht.

Sehr gerne würd ich lieber std::string benutzen, aber ich will das array an den Befehl execvp (nur linux) übergeben und der braucht eben ein char* x[...] array...

edit: per hand:

const char* source[] = {"eins", "zwei", "drei"};
std::size_t source_size = sizeof(source)/sizeof(*source);

char* dest = new char[source_size];
std::size_t dest_size(0);
try
{
  for(; dest_size != source_size; ++dest_size)
  {
    dest[dest_size] = new char[strlen(source[dest_size])+1];
    std::strcpy(dest[dest_size], source[dest_size]);
  }
}
catch(...)
{
  while(dest_size != 0)
    delete[] dest[--dest_size];
  throw;
}

a_fct_like_main(dest_size, dest);

while(dest_size != 0)
  delete[] dest[--dest_size];
delete[] dest;

so in etwa zumindest... -> nimm string, falls const char* wirklich reicht^^

char *std_argv[]={"A", "B"};
char *std_argv2[]={"bla", "..."};//(soll später auch eingefügt werden)
char*argv[sizeof(std_argv)+sizeof(std_argv2)+2]; //+2 einfach ignorieren ;-)
...
for(int arg=0; arg < (sizeof(std_argv)); arg++){

sizeof(std_argv) ist Murks. sizeof(std_argv)/sizeof(std_argv[0]) ist das, was Du willst.

[MOP] schrieb:

[b]strncpy(argv[arg],std_argv[arg],sizeof(argv[arg]-1));[/b] //in dieser Zeile kommt die ausgabe: [b]Segmentation fault[/b]
}

Hast Du die Zeiger in argv auch initialisiert? Die müssen ja irgendwo hinzeigen, wo Du die Daten hinkopieren darfst. Was soll das sizeof(argv[arg]-1) ?!

Warum denn überhaupt so umständlich? Diese Low-Level-Frickelei ist doch unschön. vector<string> schon probiert? Es sieht ja eh schon so aus, als ob Du char* wie std::string behandeln würdest und char*[] wie ein vector<string> und sizeof als vector::size und string::length.

Gruß,
SP

so in etwa zumindest... -> nimm string, falls const char* wirklich reicht^^

Es verbietet auch keiner, dass man die Frickelei mit std::string erledigt und anschließend das Ergebnis in char* kopiert, falls const char* nicht reicht.

vector<string> args(...);
...
...
char* hier_rein[args.size()];
    for(size_t x = 0; x<args.size();x++){
       [b] args[x].copy(hier_rein[x],args[x].length(),0);//Fehler: Segmentation Fault[/b]
}

Das mit den vectoren ist neu für mich, kann sein, dass ich den vector falsch benutze
mfg [mop]

Aber ich muss diesen vector<string> jetzt in ein char array (char* array[...]) hinenkopieren.

Musst du wirklich? um was zu tun?

// ===== cstring_array.hpp ==============================================================================
#include <vector>
#include <string>

class cstring_array
{
	public:
		cstring_array(const std::vector<std::string>& string_vec);
		~cstring_array();

		char** get_cstrings();

	private: // vorerst Kopien verbieten
		cstring_array(const cstring_array& origin);
		void operator=(const cstring_array& origin);

	private:
		std::vector<char*> m_strings;
};

// ===== cstring_array.cpp ==============================================================================
#include "cstring_array.hpp"

#include <algorithm>
#include <iterator>

char* create_cstring(const std::string& str)
{
	char* cstr = new char[str.size()+1];
	std::copy(str.begin(), str.end(), cstr);
	cstr[str.size()] = '\0';

	return cstr;
}

void destroy_cstring(char* cstr)
{
	delete[] cstr;
}

cstring_array::cstring_array(const std::vector<std::string>& string_vec)
: m_strings()
{
	std::transform(string_vec.begin(), string_vec.end(), std::back_inserter(m_strings), &create_cstring);
}

cstring_array::~cstring_array()
{
	std::for_each(m_strings.begin(), m_strings.end(), &destroy_cstring);
}

char** cstring_array::get_cstrings()
{
	// Funktioniert nur bei std::vector, weil dieser Elemente an einem Stück garantiert.
	return &m_strings[0];
}

Eine Anwendung kann folgendermassen aussehen:

// ===== main.cpp =======================================================================================
int main()
{
	std::vector<std::string> vec;
	vec.push_back("aaa");
	vec.push_back("bbbbb");
	vec.push_back("cc");

	cstring_array wrapper(vec);
	char** cstrings = wrapper.get_cstrings();
}

viele grüße
[mop]

Danke Nexius

Kein Problem. Aber schreib meinen Namen richtig!

[MOP] schrieb:

Nur noch eine Frage : Was muss ich in der cstring_array.cpp ändern, dass beim array am Schluss noch ein 0x0 array-wert einfügt, brauch ich auch für die execvp

Du könntest im Konstruktor nach der Kopie manuell einen Nullzeiger ans Ende anhängen:

cstring_array::cstring_array(const std::vector<std::string>& string_vec)
: m_strings()
{
    std::transform(string_vec.begin(), string_vec.end(), std::back_inserter(m_strings), &create_cstring);
    m_strings.push_back(0); // <--
}

[MOP] schrieb:

Würd es selber machen, wenn ich deinen code Verstanden hätte (beschäftige mich noch nicht lange mit vectoren), aber jetzt zählt erstmal, dass es funktioniert

Ich hoffe mal, die Implementierung ist so korrekt; ich habe nicht gross getestet. Wenn es Probleme gibt, schreib wieder. Mit der Zeit wirst du den Code sicher verstehen, dann könntest du ihn auch deinen Wünschen anpassen, wenn du plötzlich mehr Funktionalität benötigst.

[MOP] schrieb:

Danke Nexius

Kein Problem. Aber schreib meinen Namen richtig!

Wird nicht wieder vorkommen , aber Nexius klingt doch auch nicht schlecht :p

Ok jetzt funktioniert alles
Danke und wenn was nicht klappt meld ich mich

mfg [mop]