folgender, ich hoffe selbst erklärender Code:

#include <iostream>

using namespace std;

void give_out(char* c)
{
    cout << c;
    cout << "\nsizeof: " << sizeof(c);  // wieso kommt hier nicht 2048, sondern die 4 der lokalen Kopie c...
    cout << "\nstrlen: " << strlen(c);
}

int main()
{

    char c[2048];
    c[0]    = 'a';
    c[1]    = 'b';
    c[2]    = 'c';
    c[3]    = 'd';
    give_out(c);
    cin.get();
    return 0;
}

Ist vielleicht nicht die feine Art, aber ich hoffe man erkennt mein Problem.
Die Sache ist stark vereinfacht... das eigentliche Problem stellte sich bei einer eigenen Winsock Klasse...
Hab ne Weile gebraucht, aber bin ziemlich sicher es liegt daran.

MfG,

Gast

mfg.

Könne auch mal 2 sein, oder mal 42!

MfG

#include <iostream>
using namespace std;

int main()
{
  char v[] = "Hallo!";
  char* p_v = &v[0];

  cout << sizeof(v) << endl;
  cout << sizeof(p_v) << endl;
  cout << sizeof(int*) << endl;
  cout << sizeof(long*) << endl;

  /**
   * Ausgabe:
   * 7
   * 4
   * 4
   * 4
  */
}

Hm... aber wie mache ich es nun, dass ich die reservierten (sind es denn reservierte?) 2048 des Parameters kriege, ohne diese vorher zu kennen...

Könne auch mal 2 sein, oder mal 42!

MfG

std::string benutzen und mit .size() arbeiten.

mfg.

void give_out(char c[])

Die Übergabe per Call by Reference funktioniert nicht, da in C++ Referenzen auf Arrays unbestimmter Größe _nicht_ unterstützt werden.

Übergabe via Call by Value:

void give_out(char c[])

Kommt immer noch 4 raus. Wenn, dann mit templates, oder sonst einfach nen vector nehmen.

#include <iostream>

void give_out(char c[]) {
    std::cout << sizeof(c) << std::endl;
}

template <int size>
void GiveOut(char (&c)[size]) {
    std::cout << sizeof(c) << std::endl;
}

int main() {
    char x[123];
    give_out(x);
    GiveOut(x);
}

4
123

mfg.

erstmal vielen dank für die schnellen Antworten.

So wie es aussieht wird es wohl auf std::string rauslaufen, auch wenn mir das noch nicht so zusagt.

Rein von der wissbegierde nun:

#include <iostream>

using namespace std;

void give_out(char c[])
{
    cout << c;
    cout << "\nsizeof: " << sizeof(c);  // wieso kommt hier nicht 2048, sondern die 4 der lokalen Kopie c...
    cout << "\nstrlen: " << strlen(c);
}

int main()
{
    char c[2048];

    c[0]    = 'a';
    c[1]    = 'b';
    c[2]    = 'c';
    c[3]    = 'd';
    give_out(c);
    cin.get();
    return 0;
}

... mag sein dass ich einfach schon zu lange vor der Kiste sitze, aber auch damit klappt es nicht.

MfG

Siehe mein Post. Das mit den Templates sollte ne gute Möglichkeit sein für dich.

mfg.

Nur noch eine Frage, da ich bisher leider noch nicht mit Templates gearbeitet habe. Wie würde ein Prototyp solch eines Templates + Funktion aussehen und wie würde dieser Prototyp in eine Klasse eingebaut werden?

//hmmm... ?
template <int size>
void give_out(char[size]);

MfG

@lucky_tux

Also bei mir kam leider Gottes wieder die verfluchte 4.

Wenn das bei dir ohne weiteres klappt muss es mit dem System zusammenhängen.
Vielleicht löst es auch dein Compiler anderst auf?

Ich habe hier ein Intel x86 Chip, Windows und MS VC++.Net ...

MfG

Die vorgestellte Lösung mit den Templates scheint problemlos zu funktionieren.

Vielen dank

Nur noch eine Frage, da ich bisher leider noch nicht mit Templates gearbeitet habe. Wie würde ein Prototyp solch eines Templates + Funktion aussehen und wie würde dieser Prototyp in eine Klasse eingebaut werden?

//hmmm... ?
template <int size>
void give_out(char[size]);

MfG

So:

template <int size> // Der Name size ist nicht dringend
void give_out(char (&arrname)[size]) { // arrname ist der Name des Parameters
//...
}

Bei dir:

template <int size>
void give_out(char (&c)[size])
{
    cout << c;
    cout << "\nsizeof: " << sizeof(c);
    cout << "\nstrlen: " << strlen(c);
}

@lucky_tux
Welchen Compiler hast du? Ich hab MinGW.

mfg.

edit: Okay, dann ist ja alles klar.

Ich wünsche eine Gute Nacht.

Es funktioniert alles soweit, bis ich anfange, dass auf meine Winsock Klasse zu übertragen. Das ganze vereinfacht ist folgendes:

// main.cpp:

#include "head.h"

// Nichtaufgeloestes Symbol? ...

int main()
{
    char c[2048];

    c[0]    = 'a';
    c[1]    = 'b';
    c[2]    = 'c';
    c[3]    = 'd';
    give_out(c);
    cin.get();
    return 0;
}

// head.h:

#include <iostream>
using namespace std;

template <int size> void give_out(char (&c)[size]);

//func.cpp:

template <int size> void give_out(char (&c)[size])
{
    cout << c;
    cout << "\nsizeof: " << size;  // wieso kommt hier nicht 2048, sondern die 4 der lokalen Kopie c...
    cout << "\nstrlen: " << strlen(c);
}

Und nun passiert folgendes, der Linker meldet:

parameter error LNK2001: Nichtaufgeloestes externes Symbol "void __cdecl give_out<2048>(char (&)[2048])" (?give_out@?$@$0IAA@@@$$FYAXAAY0IAA@D@Z)

Wie immer die 2 Fragen:

- Wieso? Das Ding ist doch aufgelöst!
- Wie behebe ich die Sache?

MfG

(aus dem Grund werden Templates grundsätzlich direkt in den Header geschrieben)

das alte Problem : Template-Implementationen müßen wie die Deklarationen im Header stehen, damit sie vom Compiler für andere Übersetzungseinheiten benutzt werden können.

/Edit : zu langsam...

bis bald
akari

Übergabe via Call by Value:

void give_out(char c[])

Du hast ja bereits selbst gemerkt, dass das nicht funktioniert. Es ist praktisch das Gleiche wie

void give_out(char* c)

Halt nur eine andere Schreibweise.

@VerdammteKopie
An deiner Stelle würde ich der give_out Funktion einen zweiten Parameter spendieren, der die Grösse des Arrays angibt. Die Template Version funktioniert zwar auch, aber nur solange, wie die Grösse eine compile-time Konstante ist. Dynamische Arrays kannst du damit vergessen.