"Rohdatentyp"

cooky451

Guten,

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";

pumuckl

cooky451 schrieb:

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.

HighLigerBiMBam

Warum sollte sich std::string nicht eigenen? Was willst du machen? Willst du vielleicht nur einen Stringstream?

und wenn du die Zusatzfunktionen nicht brauchst, und zudem vorher noch ungefähr weißt, wie groß dein Array sein muss, kannst du auch gleich ein herkömmliches C++ Array benutzen.

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

Dagegen spricht eigentlich nix...

Was hast du denn für Daten?

cooky451

Unter "Rohdaten" verstehe ich einfach ein byte-array in dem nicht nur Text steht. (Jaja, Texte sind auch nur Zahlen, aber std::string würde ich hier nicht sehr bezeichnend finden ;))
Konkret möchte ich einen Datentyp den ich
1. Nach seiner größe fragen kann (vector.size())
2. Der mir einen nicht konstanten, also beschreibbaren char* liefern kann (vector.data())
3. Den ich trotzdem möglichst einfach (gerade mit Text) beschreibben kann.
(Hier fehlt irgendwie ein Konstruktor für vector oder sowas..)

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

hustbaer

Antwort auf deine ursprüngliche Frage:
Man verwendet für sowas std::vector<char> bzw. std::vector<unsigned char>

hustbaer

cooky451 schrieb:

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";

Also eigentlich spricht trotzdem nicht gegen char * mit einer Variablen als Längenangabe... Und eigentlich spricht auch nix gegen std::string..
Nur weil der Inhalt vielleicht nicht unbedingt als Zeichen interpretiert werden sollte, heißt das ja nicht, dass man nicht trotzdem alles dort reinwerfen kann, was der char-Wertebereich hergibt. Zumindest soweit die Theorie...

cooky451

std::string kann man aber über string.data() nicht beschreiben, der Datentyp soll einen char* und nicht nur einen const char* liefern können.

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

SeppJ

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));
}

Vielleicht hast du ja auch einen konkreten Anwendungsfall, so dass man dir gezielter helfen kann.

SeppJ schrieb:

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*

SeppJ

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?

cooky451

Oder ich schreib mir ne Wrapper-Klasse für std::vector? Oder ich bleibe einfach bei --C

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....

Ethon

Warum wird eigentlich prinzipiell immer dazu geraten std::vector zu nehmen und nicht boost::array bzw std::array?

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 ...

cooky451

std::array kenne ich gar nicht.. das gibts?^^
Kann das auf www.cplusplus.com auch nicht finden..

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?

HighLigerBiMBam

Ich denke er meint std::tr1::array, was dann soviel ist wie boost::array.

Alternativ so:

#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';
}

cooky451

Das ist einfach weil strlen() zu low wär

Wenn dir strlen() zu low ist, dann wären das noch zwei Möglichkeiten :

#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.

&quot;Rohdatentyp&quot;

"Rohdatentyp"