Integer Array initialisieren

rewe

Wie kann ich den Array initialisieren, so dass jedes Element den Wert 0 hat?

int* pInt=NULL;
pInt = new int[Func()]; // Func gibt eine Ganzzahl zurück

delete []pInt

7H3 N4C3R

Bitteschön:

const size_t s = Func();
int* pInt = new int[s];
memset( pInt, 0, s);

delete []pInt

Sobald du nicht nur triviale Datentypen hast, muss man sich aber über eine andere Art der Initialisierung Gedanken machen.

rewe

Danke.

gibts nicht auch noch eine Methode mit geschweiften Klammern?

7H3 N4C3R

Nope. Die gibts nur für statische Arrays.

volkard

int* pInt = new int[Func()];

statt zwei zeilen.

und was ist das für eine komische variablenbenennung. zum einen hat inzwischen fast jeder bemerkt, daß UN ein irrweg war. und zum anderen wäre dies sogar komische UN.

rewe

volkard schrieb:

int* pInt = new int[Func()];
statt zwei zeilen.

und was ist das für eine komische variablenbenennung.

Variablenbezeichnung: pVariablenName; (p für Pointer)

volkard schrieb:

[
zum einen hat inzwischen fast jeder bemerkt, daß UN ein irrweg war. und zum anderen wäre dies sogar komische UN.

rofl. Hab den Satz auch nach merhamligem Lesen nicht kapiert
Was war ein Irrweg? UN?

rewe

7H3 N4C3R schrieb:

Nope. Die gibts nur für statische Arrays.

Ok. Dann brauch ich memset.

UN == Ungarische Notation
=>Kürzel des Typs als Variablen-Prefix

rewe

boolero schrieb:

UN == Ungarische Notation
=>Kürzel des Typs als Variablen-Prefix

ähm, hab glaub auch schon gehört, daß das ein Irrweg sein soll. Ist eben (noch?) Coding Guideline hier

rewe

[quote="7H3 N4C3R"]Bitteschön:

const size_t s = Func();
int* pInt = new int[s];
memset( pInt, 0, s);

delete []pInt

quote]

Nochmal kurz zum eigentlichen Problem zurück. Hab das jetzt so. Aber die Elemente haben nach memset nicht den Wert 0...

rewe

Richtig wäre gewesen...

const size_t s = Func(); 
int* pInt = new int[s]; 
memset( pInt, 0, s*sizeof(int)); 

delete []pInt

So funktionierts jedenfalls...

Braunstein

Kann es sein, dass ein int mehr als ein Byte hat?
memset( pInt, 0, s*sizeof(int));
[edit]Ok, zu spät.[edit]

rewe

Braunstein schrieb:

Kann es sein, dass ein int mehr als ein Byte hat?
memset( pInt, 0, s*sizeof(int));
[edit]Ok, zu spät.[edit]

Sag auch

Und ein double dann erst, SOGAR GANZE 8 Bytes. Nur noch KRASS das...

7H3 N4C3R

Hm du hast recht, es ist noch früh

const size_t s = Func();
int* pInt = new int[s];
memset( pInt, 0, s * sizeof(int));

delete []pInt

und irgendwie posten noch alle in rasender Geschwindigkeit... ich geh wieder ins Bett -.-

volkard

rewe schrieb:

ähm, hab glaub auch schon gehört, daß das ein Irrweg sein soll. Ist eben (noch?) Coding Guideline hier

na, dann.
die interne guideline geht natürlich vor.

aber dann zeigt pInt nicht auf einen int, ist also kein zeiger auf int, sondern zeigt auf den ersten von vielen ints, ist also ein array of int. und aInt wäre besser als pInt.

aber vielleicht habt ihr ja ne gelockerte UN drauf, also sowas wie p (zeiger) und n (int) und h (handle) mal davor, aber nix voll krypisches wie m_rapfnHandler[] (membervariable mit referenz auf array von funktionszeigern).

Mit fill bzw. fill_n geht das Initialisieren eleganter und funktioniert auch mit benutzerdefinierten Typen.
Beispiel:

#include <iostream>
#include <iterator>
#include <algorithm>

using namespace std;

class foo
{
public:
    foo(){}
    explicit foo(char c):m_c(c){}
    friend ostream &operator<<(ostream &out, const foo &f)
    {
        return out<<"Foo:"<<f.m_c;
    }
private:
    char m_c;
};

int main()
{
    const size_t N = 10;
    foo *foos;
    int *zahlen = new int[N];

    fill(zahlen, zahlen+N, 0);   
    copy(zahlen, zahlen+N, ostream_iterator<int>(cout, "     "));
    delete []zahlen;
    cout<<endl;

    foos = new foo[N];
    fill_n(foos, N, foo('A'));
    copy(foos, foos+N, ostream_iterator<foo>(cout, " "));
    delete []foos;
    cout<<endl;

    cin.get();
}