Das klappt natürlich nicht (gibt Größe des Zeigers aus)! Man muss noch die Anzahl der Elemente an die foo übergeben...
ABER nun kommt mein Chef, und behauptet, man könnte die Größe des Arrays feststellen, obwohl man nur dessen Adresse übergibt!!
Was sagt ihr denn dazu??

int array[5];

int size = sizeof(array)/sizeof(int);

kann man natürlich noch allgemeiner schreiben...

also erstmal heisst es nach neuestem Standard

int main()
{
    ...
}

Dann versteh ich deine Frage nicht ganz.
Üblicherweise legst du vorher die Größe eines Arrays fest, es sei denn, du willst dessen Größe dynamisch zur Laufzeit bestimmen.
Bei einer konkreteren Frage, kann man dir vielleicht eher helfen

Also man hat ja nur diese Funktion, und nun soll man feststellen, wie groß arrDummy is.

also erstmal heisst es nach neuestem Standard

int main()
{
    ...
}

Dann versteh ich deine Frage nicht ganz.
Üblicherweise legst du vorher die Größe eines Arrays fest, es sei denn, du willst dessen Größe dynamisch zur Laufzeit bestimmen.
Bei einer konkreteren Frage, kann man dir vielleicht eher helfen

PS: Eine Möglichkeit gibt es noch - du kannst dich durch die Speicherverwaltung deines Betriebssystems durchwühlen und nachsehen, wo es die Größe der reservierten Heap-Blöcke ablegt (new/delete wissen schließlich, wie groß das Array ist). Aber das ist weder portabel noch besonders komfortabel.

müsste so klappen

oder mache es einfach so
#define array_size(array) sizeof(array)/aizeof(array[0])

müsste so klappen

Solange du das Array direkt vor Ort hast, ja (siehe GPC's Beitrag) - aber wenn du nur über einen Zeiger darauf zugreifen kannst, nützt dir das gar nichts:

#define array_size(array) sizeof(array)/aizeof(array[0])

void do_something(double* data)
{
  int size = array_size(data);//liefert Müll
  ...
}

int main()
{
  double data[]={1,2,3,4,5};
  int size = array_size(data);//hier funktioniert's
  do_something(data);//das bekommt nur einen Zeiger, aber keine Größenangaben
  ...
}

(und spätestens wenn du deinen Speicher mit new[] anforderst, kannst du dessen Größe überhaupt nicht mehr auf diese Weise bestimmen)

Mein Chef hat sowas gesagt, dass wohl intern so eine Art Markierung sein soll...

Mein Chef hat sowas gesagt, dass wohl intern so eine Art Markierung sein soll...

Dann hat Dein Chef unrecht. Jedenfalls ist "so eine Art Markierung" keinesfalls portabel. Es seidenn er meint nullterminierte Arrays, das soll er Dir (oder Du uns :D) dann aber auch sagen. Wobei man dann nicht mehr die Zahl 0.0 übergeben könnte.

Mein Chef hat sowas gesagt, dass wohl intern so eine Art Markierung sein soll...

Delphi- oder Java-geschädigt?
Du kannst std::vector<> benutzen, der speichert die Länge mit ist und wie ein Array handhabbar. Oder, wenn du die STL nicht benutzen willst, folgendes struct:

template <typename T>
struct array_t {
    int len;
    T *values;
};

Zu benutzen wie folgt:

struct array_t SomeArray;
array_t.values = malloc(42);
if (array_t.values) {
    array_t.len = 42;
};

Man kann sich noch Hilfsfunktionen zum Handling schreiben, oder es gleich richtig machen und Konstruktoren und Operatoren für array_t einführen, aber dann landet man am Ende bei einem nicht-standardisierten Nachbau von std::vector<>, also kann man auch gleich den benutzen.

void foo(double* arrDummy) 
{ 
}

Also man hat ja nur diese Funktion, und nun soll man feststellen, wie groß arrDummy is.

Wenn du eine Funktion wie foo hast, kannst du nicht nur nicht rausfinden, wieviele Elemente sich hinter arrDummy verbergen. Nein, es kommt noch schlimmer: du kannst nicht mal prüfen, ob arrDummy überhaupt auf ein Array verweist.

Wenn foo also nicht entweder eine bestimmte Konvention vorschreibt (z.B. wie das bei C-Strings durch die Einführung der Nullterminierung gemacht wurde) oder aber noch einen Größenparameter spendiert bekommt, kann foo nichts weiter annehmen, als dass es sich bei arrDummy um einen Zeiger auf ein double handelt.

...kann foo nichts weiter annehmen, als dass es sich bei arrDummy um einen Zeiger auf ein double handelt.

noch nicht mal das...

HumeSikkins schrieb:

...kann foo nichts weiter annehmen, als dass es sich bei arrDummy um einen Zeiger auf ein double handelt.

noch nicht mal das...

Natürlich kann ein Aufrufer auch einfach einen Nullpointer übergeben oder einen nach double*-gecastateten Zeiger auf ein Elefant-Objekt. Was ist eigentlich damit sagen wollte ist, dass die Funktion, wenn sie nicht irgendeine zusätzliche Konvention festlegt, von einem *einzelnen* Objekt (besser: 0..1) ausgehen muss, nicht von einem Array.

@net:

Wobei man dann nicht mehr die Zahl 0.0 übergeben könnte.

Naja, bei einem double würde ich als Endemarke vermutlich NaN verwenden

...dass die Funktion, wenn sie nicht irgendeine zusätzliche Konvention festlegt, von einem *einzelnen* Objekt (besser: 0..1) ausgehen muss, nicht von einem Array.

naja, wenn man nur den funktiosnkopf kennt: 'void blubb(double *x)' kann man eigentlich von garnix ausgehen. ist es ein array? (warum hat er denn nich x[] geschrieben?) ist es ein pointer auf ein einzelnes double? (soll das verändert werden oder wieso ist das ein pointer?). wir wissen es nicht...

Und ja, mein Chef ist Java "geschädigt", denke auch das es daran liegt, dass er sich zu solchen Äußerungen hinreißen lässt.

Nächste Woche ist er wieder da, dann soll er mir zeigen, wie das gehen soll, und ich denke, dann wird auch er einsehen, dass das mit C++ einfach nciht geht.

@tommie: malloc() im Zusammenhang mit C++ Klassen macht sich eher ungünstig. Wenn schon, dann solltest du lieber new nehmen, um den Speicher anzufordern.

Stimmt prinzipiell, macht hier aber keinen Unterschied, weil ich einen Pointer initialisiert habe. Allerdings habe ich ein "*sizeof(T)" vergessen, ein weiterer Grund, warum man dafür Memberfunktionen nehmen soll, oder besser gleich std::vector<>.