welchen Datentyp (Objekt? STL-Container? Habe (noch) wenig Ahnung von C++ ) nutzt man eigentlich für "Rohdaten" äquivalent zu einem char array in C?
std::string eignet sich irgendwie nicht so wirklich..
Habe mal bei boost::asio geschaut in welchen Datentyp die zB. als buffer nutzen - und - na klasse - boost::array. (oO?^^) ( http://www.boost.org/doc/libs/1_39_0/doc/html/boost_asio/tutorial/tutdaytime1.html )

std::vector wäre passend, allerdings fehlt mir hier irgendwie die simple "Beschreibbarkeit".
Wie würde man zB. folgenden Ausdruck mit C++ realisieren?

char bar[] = 
  "Hallo, ich bin ein Test-String\n"
  "Really!\n"
  "\n";

nutzt man eigentlich für "Rohdaten" äquivalent zu einem char array in C?

Was verstehst du unter Rohdaten? Auch C-Arrays können alle möglichen Typen beinhalten.
Davon abgesehen ist std::vector genauso leicht beschreibbar wie ein C-Array, bietet aber darüber hinaus noch einige zusätzliche Features. Genau genommen IST ein std::vector ein (gekapseltes) C-Array.

Also für jegliche Art von Buffer nehm ich auch gern *char Buffer.

Dagegen spricht eigentlich nix...

Was hast du denn für Daten?

Wobei das Stichwort stringstream gar nicht schlecht ist.. könnte man vielleicht einen stringstream auf vector.data() erstellen und den so beschreiben? Oder geht das noch einfacher?

@Aufpasser -> Naja, ich komme sozusagen von C und möchte mich jetzt etwas in C++ reindenken und das möglichst ohne immer gleich den leichten, weil bekannten C Weg zu gehen

Wie würde man zB. folgenden Ausdruck mit C++ realisieren?

char bar[] = 
  "Hallo, ich bin ein Test-String\n"
  "Really!\n"
  "\n";

Äh.
So?

char const bar[] = 
  "Hallo, ich bin ein Test-String\n"
  "Really!\n"
  "\n";

@hustbaer
Und jetzt das ganze noch mal mit std::vector<char> und ich bin glücklich

@hustbaer
Und jetzt das ganze noch mal mit std::vector<char> und ich bin glücklich

#include <iterator>
#include <vector>

template<class InputIterator, class OutputIterator>
  OutputIterator strcpy ( InputIterator first, OutputIterator result )
{
  while (*first) *result++ = *first++;
  return result;
}

int main()
{
  std::vector<char> test;
  strcpy("Hallo Welt!\n",std::back_inserter(test));
}

cooky451 schrieb:

@hustbaer
Und jetzt das ganze noch mal mit std::vector<char> und ich bin glücklich

#include <iterator>
#include <vector>

template<class InputIterator, class OutputIterator>
  OutputIterator strcpy ( InputIterator first, OutputIterator result )
{
  while (*first) *result++ = *first++;
  return result;
}

int main()
{
  std::vector<char> test;
  strcpy("Hallo Welt!\n",std::back_inserter(test));
}

ach du heilige scheiße... nimm doch in gottes namen einfach char*

ach du heilige scheiße... nimm doch in gottes namen einfach char*

Und dann baut er ein Speicherleck nach dem anderen, kommt mit der Übergabe an Funktionen nicht zurecht und und und...

Das alles um sich die obigen drei Zeilen Code zu sparen?

Aufpasser schrieb:

ach du heilige scheiße... nimm doch in gottes namen einfach char*

Und dann baut er ein Speicherleck nach dem anderen, kommt mit der Übergabe an Funktionen nicht zurecht und und und...

Das alles um sich die obigen drei Zeilen Code zu sparen?

Ist aber schon interessant, dass du jedem unterstellst, mit C++-Arrays nicht ordentlich umgehen zu können und ihm stattdessen nahelegst ein Template zu programmieren....

Seitdem ich boost::array entdeckt hab, sind 50% meiner STL-Vektoren aus dem Code geflogen. Meistens ist es deutlich effektiver ein bischen zu viel Speicher zu verbrauchen (der meistens ja auch noch auf dem Stack liegt ... und Vektor verschwendet meistens noch mehr) als permnanent Speicher zu allozieren.
Mir ist jedenfalls ein guter Geschwindigkeitszuwachs aufgefallen.

Dass das Ganze natürlich nur Sinn macht, wenn man ungefähr den Speicherbedarf einschätzen kann ist klar ...

Aber mal abgesehen davon..

class MyBuf
{
private:
  std::vector<char> m_vector;
public:
  MyBuf()
  {
  }
  MyBuf(std::string& text)
  {
    *this = text;
  }
  MyBuf(char *text)
  {
    *this = text;
  }
  void operator = (std::string& text)
  {
    m_vector.resize(text.length() + 1);
    strcpy(m_vector.data(), text.c_str());
  }
  void operator = (char *text)
  {
    std::string l_tmp = text;
    *this = l_tmp;
  }
  char *data()
  {
    return m_vector.data();
  }
  void resize(std::size_t size)
  {
    m_vector.resize(size);
  }
  std::size_t size()
  {
    return m_vector.size();
  }
};

Total ehm.. naja.. Klasse?

#include <iostream>
#include <vector>

const char * const txt = "Hallo Welt!";

static size_t len(const char * c)
{
  size_t len;
  for (len = 0; *c++; ++len)
    ;
  return len;
}

int main()
{
  std::vector<char> buf(txt, txt + len(txt) + 1);
  std::cout << &buf[0] << '\n';
}

#include <iostream>
#include <vector>

std::vector<char> cstr2vec(const char * cstr)
{
  std::vector<char> vec;
  for (; *cstr; ++cstr)
    vec.push_back(*cstr);
  vec.push_back('\0');
  return vec;
}

int main()
{
  {
    const char anf [] = "Hallo Welt!";
    const char end [] = "";

    std::vector<char> buf(anf, end);
    std::cout << &buf[0] << '\n';
  }
  {
    std::vector<char> buf(cstr2vec("Hallo Welt!"));
    std::cout << &buf[0] << '\n';
  }
}

Wenn du dich nur an strlen als C-Funktion störst, dann geht auch:

std::string("Hallo").length()

Das mach aber auch nichts anderes.

cooky451, vielleicht ein paar Verbesserungsvorschläge für deine Klasse:

• std::vector besitzt keine Memberfunktion data() .
• Mach deine Methoden const -korrekt. Sowohl die Memberfunktion selbst als auch ihre Parameter sind teilweise unnötig eingeschränkt durch Zeiger/Referenzen auf veränderbare Objekte.
• Im Kopierkonstruktor den Zuweisungsoperator aufzurufen ist eher unüblich. Mach es lieber umgekehrt mit dem Copy-and-Swap-Idiom.
• Der Umweg von char* über std::string ist unnötig ineffizient. Auch hier könntest du mit dem umgekehrten Weg besser fahren (unter Benutzung von std::string::c_str() ).

const char anf [] = "Hallo Welt!";
    const char end [] = "";

    std::vector<char> buf(anf, end);

Das ist ziemlich undefiniert.

SeppJ schrieb:

Aufpasser schrieb:

ach du heilige scheiße... nimm doch in gottes namen einfach char*

Und dann baut er ein Speicherleck nach dem anderen, kommt mit der Übergabe an Funktionen nicht zurecht und und und...

Das alles um sich die obigen drei Zeilen Code zu sparen?

Ist aber schon interessant, dass du jedem unterstellst, mit C++-Arrays nicht ordentlich umgehen zu können und ihm stattdessen nahelegst ein Template zu programmieren....

Er unterstellt nur, dass jeder Fehler macht, und wer viele Fehler macht, macht die auch mal bei C++-Arrays - und das führt dann häufig zu Speicherlecks, weil das eben einer der Schwachpunkte von C++-Arrays gegenüber std::vectoren ist.