question about pointers.

Discussion in 'C++' started by wongjoekmeu@yahoo.com, Jan 26, 2005.

  1. Guest

    Hello All,
    I am learning C++ at the moment. Going through the book of SAM of
    learning C++ in 21 days I have learned about pointers that it is good
    custome to always initialise them and to use delete before you try to
    give it a new address.
    Can anyone explain to me why this code below which seems to voilate
    this rule works ?

    -------------------
    int main()
    20: {
    21: CAT * Family[500];
    22: int i;
    23: CAT * pCat;
    24: for (i = 0; i < 500; i++)
    25: {
    26: pCat = new CAT;
    27: pCat->SetAge(2*i +1);
    28: Family = pCat;
    29: }
    30:
    31: for (i = 0; i < 500; i++)
    32: {
    33: cout << "Cat #" << i+1 << ": ";
    34: cout << Family->GetAge() << endl;
    35: }
    36: return 0;
    37: }
    ---------------
    This code seems to work. But I thought it should be different according
    to the customs of pointers. So I changed the code to;
    ----------------
    int main()
    20: {
    21: CAT * Family[500];
    22: int i;
    23: CAT * pCat = 0;
    24: for (i = 0; i < 500; i++)
    25: {
    26: pCat = new CAT;
    27: pCat->SetAge(2*i +1);
    28: Family = pCat;
    delete pCat;
    pCat = 0;
    29: }
    30:
    31: for (i = 0; i < 500; i++)
    32: {
    33: cout << "Cat #" << i+1 << ": ";
    34: cout << Family->GetAge() << endl;
    35: }
    36: return 0;
    37: }
    -----------------------
    So I initialised pCat to the null pointer and added the lines between
    line 28-29. And now the code does not work. The output on line 34 gives
    only zeros. Can anyone explain me what I am doing wrong. To my opinion
    I am doing everything correct and according to the rules. But What am I
    doing wrong ??
    Thank you in advance for answering the question.

    Best Regards,
    Robert
    , Jan 26, 2005
    #1
    1. Advertising

  2. <> schrieb im Newsbeitrag
    news:...
    > Hello All,
    > I am learning C++ at the moment. Going through the book of SAM of
    > learning C++ in 21 days I have learned about pointers that it is
    > good
    > custome to always initialise them and to use delete before you try
    > to
    > give it a new address.
    > Can anyone explain to me why this code below which seems to voilate
    > this rule works ?
    >
    > -------------------
    > int main()
    > 20: {
    > 21: CAT * Family[500];
    > 22: int i;
    > 23: CAT * pCat;
    > 24: for (i = 0; i < 500; i++)
    > 25: {
    > 26: pCat = new CAT;
    > 27: pCat->SetAge(2*i +1);
    > 28: Family = pCat;
    > 29: }
    > 30:
    > 31: for (i = 0; i < 500; i++)
    > 32: {
    > 33: cout << "Cat #" << i+1 << ": ";
    > 34: cout << Family->GetAge() << endl;
    > 35: }
    > 36: return 0;
    > 37: }
    > ---------------
    > This code seems to work. But I thought it should be different
    > according
    > to the customs of pointers. So I changed the code to;
    > ----------------
    > int main()
    > 20: {
    > 21: CAT * Family[500];
    > 22: int i;
    > 23: CAT * pCat = 0;
    > 24: for (i = 0; i < 500; i++)
    > 25: {
    > 26: pCat = new CAT;
    > 27: pCat->SetAge(2*i +1);
    > 28: Family = pCat;
    > delete pCat;
    > pCat = 0;


    ouch!
    pCat points to valid memory.
    Family points to exactly that same memory
    Now you delete that memory pointed to by pCat
    Guess where Family is pointing to now!?
    Gernot Frisch, Jan 26, 2005
    #2
    1. Advertising

  3. "" wrote:
    >
    > Hello All,
    > I am learning C++ at the moment. Going through the book of SAM of
    > learning C++ in 21 days I have learned about pointers that it is good
    > custome to always initialise them and to use delete before you try to
    > give it a new address.
    > Can anyone explain to me why this code below which seems to voilate
    > this rule works ?
    >

    [snip]

    > So I initialised pCat to the null pointer and added the lines between
    > line 28-29. And now the code does not work. The output on line 34 gives
    > only zeros. Can anyone explain me what I am doing wrong. To my opinion
    > I am doing everything correct and according to the rules. But What am I
    > doing wrong ??


    What the book did wrong: It obviously explained pointers and how to
    deal with them in a way you did not understand.
    What you did wrong: You don't understand pointers or to be more exact:
    danymic memory allocation by now.

    Here is the deal:
    A pointer is a place in memory, just like any other variable that holds
    the memory address of some other items in memory. As such it has a name
    just like any other variable.

    So when you program does

    CAT * Family[500];
    CAT * pCat;

    you create 2 of those variables. Here they are:

    pCat Family
    +----------+ +------------+
    | | | |
    +----------+ +------------+
    | |
    +------------+
    | |
    +------------+
    | |
    . .
    . .
    . .
    | |
    +------------+
    | |
    +------------+

    Each of those rectangles contains a pointer. At the moment they
    are pointing to nowhere in particular, but that will change in
    a moment. When a pointer points to something, I will indicate
    that fact by placing an arrow in it. The arrow starts at the
    rectangle and ends at the thing 'pointed to'. Note: If I want
    to indicate that a pointer points to newhere, I simply write
    a 0 into the rectangle. Since none of the rectangles contain
    a 0 right now, I can conclude that nothing can be said about the
    state of the pointers right now.

    You program contines with

    pCat = new CAT;

    in the loop. OK lets perform the operation at i == 0

    new CAT That means that a CAT object is born somewhere in memory ...
    pCat = new CAt ... and pCat gets a pointer to it

    pCat Family
    +----------+ +------------+
    | o | | |
    +----|-----+ +------------+
    | | |
    | +------------+
    | | |
    | +------------+
    | | |
    | . .
    | . .
    | . .
    | | |
    | +------------+
    | | |
    | +------------+
    |
    | +------------+
    +----------------------------------------->| Age: |
    +------------+

    Next:
    pCat->SetAge(2*i + 1);

    pCat Look up the rectangle called pCat
    pCat-> There must be an arrow originating from it
    Follow that arrow and you will get to an
    object of type CAT
    pCat->SetAge From that object, call the member function setAge
    pCat->SetAge(2*i+1) and pass it the value 1 (remember, we ar ein the first
    loop iteration, i has a value of 0)

    I guess that SetAge simply will set the Age field, thus

    pCat Family
    +----------+ +------------+
    | o | | |
    +----|-----+ +------------+
    | | |
    | +------------+
    | | |
    | +------------+
    | | |
    | . .
    | . .
    | . .
    | | |
    | +------------+
    | | |
    | +------------+
    |
    | +------------+
    +----------------------------------------->| Age: 1 |
    +------------+

    Next:
    Family = pCat;

    Ok. In the array Family, look up the rectangle which corresponds to
    the 0-th entry. Make that entry point to the same object as pCat

    pCat Family
    +----------+ +------------+
    | o | | o----------------+
    +----|-----+ +------------+ |
    | | | |
    | +------------+ |
    | | | |
    | +------------+ |
    | | | |
    | . . |
    | . . |
    | . . |
    | | | |
    | +------------+ |
    | | | |
    | +------------+ |
    | v
    | +------------+
    +----------------------------------------->| Age: 1 |
    +------------+

    Loop finished, lets make another turn through the loop, for i == 1

    pCat = new CAT;

    pCat Family
    +----------+ +------------+
    | o | | o----------------+
    +----|-----+ +------------+ |
    | | | |
    | +------------+ |
    | | | |
    | +------------+ |
    | | | |
    | . . |
    | . . |
    | . . |
    | | | |
    | +------------+ |
    | | | |
    | +------------+ |
    | v
    | +------------+
    | | Age: 1 |
    | +------------+
    |
    |
    | +------------+
    +-------------------------------------->| Age: |
    +------------+

    pCat->SetAge( 2*i + 1);

    pCat Family
    +----------+ +------------+
    | o | | o----------------+
    +----|-----+ +------------+ |
    | | | |
    | +------------+ |
    | | | |
    | +------------+ |
    | | | |
    | . . |
    | . . |
    | . . |
    | | | |
    | +------------+ |
    | | | |
    | +------------+ |
    | v
    | +------------+
    | | Age: 1 |
    | +------------+
    |
    |
    | +------------+
    +-------------------------------------->| Age: 3 |
    +------------+

    Family = pCat;

    pCat Family
    +----------+ +------------+
    | o | | o----------------+
    +----|-----+ +------------+ |
    | | o------------+ |
    | +------------+ | |
    | | | | |
    | +------------+ | |
    | | | | |
    | . . | |
    | . . | |
    | . . | |
    | | | | |
    | +------------+ | |
    | | | | |
    | +------------+ | |
    | | v
    | | +------------+
    | | | Age: 1 |
    | | +------------+
    | |
    | v
    | +------------+
    +------------------------------------->| Age: 3 |
    +------------+

    I guess you can now see what is going on:
    New CAT objects are allocated, a pointer to them is held in pCat.
    The object gets assigned some value and finaly the pointer in the
    Family array is made to point to that object. So in the end, the
    graphics would look like this: The family rectangle has pointers
    pointing all over the place to CAT object, each with an Age number
    set.

    Now the final loop in the original program simply walks through
    that array,

    for( i = 0; i < 500; i++ )

    follows each pointer

    Family->

    tells the object at the end of the arrow to give its age

    Family->GetAge()

    and outputs the number returned by the object

    cout << Family->GetAge() << endl;

    So far so good.
    But then came you and modified the program. Lets see how this influences
    the whole program:

    Again 2 Pointers are created:

    CAT * Family[500];
    CAT * pCat;

    pCat Family
    +----------+ +------------+
    | | | |
    +----------+ +------------+
    | |
    +------------+
    | |
    +------------+
    | |
    . .
    . .
    . .
    | |
    +------------+
    | |
    +------------+

    in the loop ( i == 0 )

    pCat = new CAT;
    pCat->SetAge( 2*i+1);
    Family = pCat;

    pCat Family
    +----------+ +------------+
    | o | | o----------------+
    +----|-----+ +------------+ |
    | | | |
    | +------------+ |
    | | | |
    | +------------+ |
    | | | |
    | . . |
    | . . |
    | . . |
    | | | |
    | +------------+ |
    | | | |
    | +------------+ |
    | v
    | +------------+
    +----------------------------------------->| Age: 1 |
    +------------+

    Nothing new so far.
    But now it comes:

    delete pCat;

    Well. delete destroyes the object pCat points to. It wipes it out of memory.

    pCat Family
    +----------+ +------------+
    | o | | o----------------+
    +----|-----+ +------------+ |
    | | | |
    | +------------+ |
    | | | |
    | +------------+ |
    | | | |
    | . . |
    | . . |
    | . . |
    | | | |
    | +------------+ |
    | | | |
    | +------------+ |
    | v
    |
    +----------------------------------------->


    pCat = 0;

    pCat Family
    +----------+ +------------+
    | 0 | | o----------------+
    +----------+ +------------+ |
    | | |
    +------------+ |
    | | |
    +------------+ |
    | | |
    . . |
    . . |
    . . |
    | | |
    +------------+ |
    | | |
    +------------+ |
    v

    Next run through the loop ( i == 1 )

    pCat = new CAT;
    pCat->SetAge( 2*i+1);
    Family = pCat;

    pCat Family
    +----------+ +------------+
    | o | | o----------------+
    +----|-----+ +------------+ |
    | | o-----------+ |
    | +------------+ | |
    | | | | |
    | +------------+ | |
    | | | | |
    | . . | |
    | . . | |
    | . . | |
    | | | | |
    | +------------+ | |
    | | | | |
    | +------------+ | |
    | | v
    | |
    | |
    | v
    | +----------+
    +---------------------------------->| Age: 3 |
    +----------+

    and again:

    delete pCat;
    pCat = 0;

    pCat Family
    +----------+ +------------+
    | O | | o----------------+
    +----------+ +------------+ |
    | o-----------+ |
    +------------+ | |
    | | | |
    +------------+ | |
    | | | |
    . . | |
    . . | |
    . . | |
    | | | |
    +------------+ | |
    | | | |
    +------------+ | |
    | v
    |
    |
    v


    I think you can imagine, what this leads to in the end. Family
    still holds a lot of pointers. But there are no objects at the
    end of all those arrows. They have all been deleted.

    Well. Above I said: it has been wiped out of memory. Technically
    this is impossible. Memory is memory. There is still memory at
    all the end points of all those arrows and it is impossible for
    memory to not hold some value. But logically those objects are no
    longer there. The content of that memory is random and depends on a
    lot of things outside your control. This is why the loop in your final
    program outputs 0. It could have operated otherwise also. You program
    could have simply crashed, because in the loop you take the pointer,
    the arrow, follow it and tell the object at the end of the arrow
    to give its age. But there is no object there any more!


    --
    Karl Heinz Buchegger
    Karl Heinz Buchegger, Jan 26, 2005
    #3
  4. On 26 Jan 2005 05:26:32 -0800,
    <> wrote:

    > Hello All,
    > I am learning C++ at the moment. Going through the book of SAM of
    > learning C++ in 21 days I have learned about pointers that it is good
    > custome to always initialise them and to use delete before you try to
    > give it a new address.
    > Can anyone explain to me why this code below which seems to voilate
    > this rule works ?


    [...]

    which only shows once more that these 21-day books are not sooo good (i
    know three of them)...

    i would make myself familiar with std::auto_ptr<> as fast as possible, and
    buy a better book, e.g.

    http://www.amazon.com/exec/obidos/t...one/purchase/ref=pd_sexpl/104-9986470-2641501

    or

    http://www.amazon.com/exec/obidos/A...65/sr=2-1/ref=pd_ka_b_2_1/104-9986470-2641501

    and so on...

    --
    have a nice day
    ulrich
    Ulrich Achleitner, Jan 26, 2005
    #4
  5. > which only shows once more that these 21-day books are not sooo good
    > (i know three of them)...


    I did the C in 21 days in 5 days and it was good. Haven't had a look
    at C++ in 21 days, though.
    -Gernot
    Gernot Frisch, Jan 26, 2005
    #5
  6. Guest

    Dear Karl Heinz Buchegger,

    Thank you for your explanation. But if I understood you properly then
    why does not the following code does not compile ?

    ----------

    int *p = new int[5];
    int *p = new int[10];

    -----------
    But when I write the following code here below which seems to be the
    same for me that I redeclare the pointer to point again to somewhere
    else, the compiler does not complain. WHy?? Do I have memory leak in
    any of these cases ?
    ---------------
    for (int i = 1; i<10; i++)
    {
    int *p = new int;
    }
    ---------------

    Robert

    Karl Heinz Buchegger wrote:
    > "" wrote:
    > >
    > > Hello All,
    > > I am learning C++ at the moment. Going through the book of SAM of
    > > learning C++ in 21 days I have learned about pointers that it is

    good
    > > custome to always initialise them and to use delete before you try

    to
    > > give it a new address.
    > > Can anyone explain to me why this code below which seems to voilate
    > > this rule works ?
    > >

    > [snip]
    >
    > > So I initialised pCat to the null pointer and added the lines

    between
    > > line 28-29. And now the code does not work. The output on line 34

    gives
    > > only zeros. Can anyone explain me what I am doing wrong. To my

    opinion
    > > I am doing everything correct and according to the rules. But What

    am I
    > > doing wrong ??

    >
    > What the book did wrong: It obviously explained pointers and how to
    > deal with them in a way you did not understand.
    > What you did wrong: You don't understand pointers or to be more

    exact:
    > danymic memory allocation by now.
    >
    > Here is the deal:
    > A pointer is a place in memory, just like any other variable that

    holds
    > the memory address of some other items in memory. As such it has a

    name
    > just like any other variable.
    >
    > So when you program does
    >
    > CAT * Family[500];
    > CAT * pCat;
    >
    > you create 2 of those variables. Here they are:
    >
    > pCat Family
    > +----------+ +------------+
    > | | | |
    > +----------+ +------------+
    > | |
    > +------------+
    > | |
    > +------------+
    > | |
    > . .
    > . .
    > . .
    > | |
    > +------------+
    > | |
    > +------------+
    >
    > Each of those rectangles contains a pointer. At the moment they
    > are pointing to nowhere in particular, but that will change in
    > a moment. When a pointer points to something, I will indicate
    > that fact by placing an arrow in it. The arrow starts at the
    > rectangle and ends at the thing 'pointed to'. Note: If I want
    > to indicate that a pointer points to newhere, I simply write
    > a 0 into the rectangle. Since none of the rectangles contain
    > a 0 right now, I can conclude that nothing can be said about the
    > state of the pointers right now.
    >
    > You program contines with
    >
    > pCat = new CAT;
    >
    > in the loop. OK lets perform the operation at i == 0
    >
    > new CAT That means that a CAT object is born somewhere in

    memory ...
    > pCat = new CAt ... and pCat gets a pointer to it
    >
    > pCat Family
    > +----------+ +------------+
    > | o | | |
    > +----|-----+ +------------+
    > | | |
    > | +------------+
    > | | |
    > | +------------+
    > | | |
    > | . .
    > | . .
    > | . .
    > | | |
    > | +------------+
    > | | |
    > | +------------+
    > |
    > | +------------+
    > +----------------------------------------->| Age: |
    > +------------+
    >
    > Next:
    > pCat->SetAge(2*i + 1);
    >
    > pCat Look up the rectangle called pCat
    > pCat-> There must be an arrow originating from it
    > Follow that arrow and you will get to an
    > object of type CAT
    > pCat->SetAge From that object, call the member function

    setAge
    > pCat->SetAge(2*i+1) and pass it the value 1 (remember, we ar ein

    the first
    > loop iteration, i has a value of 0)
    >
    > I guess that SetAge simply will set the Age field, thus
    >
    > pCat Family
    > +----------+ +------------+
    > | o | | |
    > +----|-----+ +------------+
    > | | |
    > | +------------+
    > | | |
    > | +------------+
    > | | |
    > | . .
    > | . .
    > | . .
    > | | |
    > | +------------+
    > | | |
    > | +------------+
    > |
    > | +------------+
    > +----------------------------------------->| Age: 1 |
    > +------------+
    >
    > Next:
    > Family = pCat;
    >
    > Ok. In the array Family, look up the rectangle which corresponds to
    > the 0-th entry. Make that entry point to the same object as pCat
    >
    > pCat Family
    > +----------+ +------------+
    > | o | | o----------------+
    > +----|-----+ +------------+ |
    > | | | |
    > | +------------+ |
    > | | | |
    > | +------------+ |
    > | | | |
    > | . . |
    > | . . |
    > | . . |
    > | | | |
    > | +------------+ |
    > | | | |
    > | +------------+ |
    > | v
    > | +------------+
    > +----------------------------------------->| Age: 1 |
    > +------------+
    >
    > Loop finished, lets make another turn through the loop, for i == 1
    >
    > pCat = new CAT;
    >
    > pCat Family
    > +----------+ +------------+
    > | o | | o----------------+
    > +----|-----+ +------------+ |
    > | | | |
    > | +------------+ |
    > | | | |
    > | +------------+ |
    > | | | |
    > | . . |
    > | . . |
    > | . . |
    > | | | |
    > | +------------+ |
    > | | | |
    > | +------------+ |
    > | v
    > | +------------+
    > | | Age: 1 |
    > | +------------+
    > |
    > |
    > | +------------+
    > +-------------------------------------->| Age: |
    > +------------+
    >
    > pCat->SetAge( 2*i + 1);
    >
    > pCat Family
    > +----------+ +------------+
    > | o | | o----------------+
    > +----|-----+ +------------+ |
    > | | | |
    > | +------------+ |
    > | | | |
    > | +------------+ |
    > | | | |
    > | . . |
    > | . . |
    > | . . |
    > | | | |
    > | +------------+ |
    > | | | |
    > | +------------+ |
    > | v
    > | +------------+
    > | | Age: 1 |
    > | +------------+
    > |
    > |
    > | +------------+
    > +-------------------------------------->| Age: 3 |
    > +------------+
    >
    > Family = pCat;
    >
    > pCat Family
    > +----------+ +------------+
    > | o | | o----------------+
    > +----|-----+ +------------+ |
    > | | o------------+ |
    > | +------------+ | |
    > | | | | |
    > | +------------+ | |
    > | | | | |
    > | . . | |
    > | . . | |
    > | . . | |
    > | | | | |
    > | +------------+ | |
    > | | | | |
    > | +------------+ | |
    > | | v
    > | | +------------+
    > | | | Age: 1 |
    > | | +------------+
    > | |
    > | v
    > | +------------+
    > +------------------------------------->| Age: 3 |
    > +------------+
    >
    > I guess you can now see what is going on:
    > New CAT objects are allocated, a pointer to them is held in pCat.
    > The object gets assigned some value and finaly the pointer in the
    > Family array is made to point to that object. So in the end, the
    > graphics would look like this: The family rectangle has pointers
    > pointing all over the place to CAT object, each with an Age number
    > set.
    >
    > Now the final loop in the original program simply walks through
    > that array,
    >
    > for( i = 0; i < 500; i++ )
    >
    > follows each pointer
    >
    > Family->
    >
    > tells the object at the end of the arrow to give its age
    >
    > Family->GetAge()
    >
    > and outputs the number returned by the object
    >
    > cout << Family->GetAge() << endl;
    >
    > So far so good.
    > But then came you and modified the program. Lets see how this

    influences
    > the whole program:
    >
    > Again 2 Pointers are created:
    >
    > CAT * Family[500];
    > CAT * pCat;
    >
    > pCat Family
    > +----------+ +------------+
    > | | | |
    > +----------+ +------------+
    > | |
    > +------------+
    > | |
    > +------------+
    > | |
    > . .
    > . .
    > . .
    > | |
    > +------------+
    > | |
    > +------------+
    >
    > in the loop ( i == 0 )
    >
    > pCat = new CAT;
    > pCat->SetAge( 2*i+1);
    > Family = pCat;
    >
    > pCat Family
    > +----------+ +------------+
    > | o | | o----------------+
    > +----|-----+ +------------+ |
    > | | | |
    > | +------------+ |
    > | | | |
    > | +------------+ |
    > | | | |
    > | . . |
    > | . . |
    > | . . |
    > | | | |
    > | +------------+ |
    > | | | |
    > | +------------+ |
    > | v
    > | +------------+
    > +----------------------------------------->| Age: 1 |
    > +------------+
    >
    > Nothing new so far.
    > But now it comes:
    >
    > delete pCat;
    >
    > Well. delete destroyes the object pCat points to. It wipes it out of

    memory.
    >
    > pCat Family
    > +----------+ +------------+
    > | o | | o----------------+
    > +----|-----+ +------------+ |
    > | | | |
    > | +------------+ |
    > | | | |
    > | +------------+ |
    > | | | |
    > | . . |
    > | . . |
    > | . . |
    > | | | |
    > | +------------+ |
    > | | | |
    > | +------------+ |
    > | v
    > |
    > +----------------------------------------->
    >
    >
    > pCat = 0;
    >
    > pCat Family
    > +----------+ +------------+
    > | 0 | | o----------------+
    > +----------+ +------------+ |
    > | | |
    > +------------+ |
    > | | |
    > +------------+ |
    > | | |
    > . . |
    > . . |
    > . . |
    > | | |
    > +------------+ |
    > | | |
    > +------------+ |
    > v
    >
    > Next run through the loop ( i == 1 )
    >
    > pCat = new CAT;
    > pCat->SetAge( 2*i+1);
    > Family = pCat;
    >
    > pCat Family
    > +----------+ +------------+
    > | o | | o----------------+
    > +----|-----+ +------------+ |
    > | | o-----------+ |
    > | +------------+ | |
    > | | | | |
    > | +------------+ | |
    > | | | | |
    > | . . | |
    > | . . | |
    > | . . | |
    > | | | | |
    > | +------------+ | |
    > | | | | |
    > | +------------+ | |
    > | | v
    > | |
    > | |
    > | v
    > | +----------+
    > +---------------------------------->| Age: 3 |
    > +----------+
    >
    > and again:
    >
    > delete pCat;
    > pCat = 0;
    >
    > pCat Family
    > +----------+ +------------+
    > | O | | o----------------+
    > +----------+ +------------+ |
    > | o-----------+ |
    > +------------+ | |
    > | | | |
    > +------------+ | |
    > | | | |
    > . . | |
    > . . | |
    > . . | |
    > | | | |
    > +------------+ | |
    > | | | |
    > +------------+ | |
    > | v
    > |
    > |
    > v
    >
    >
    > I think you can imagine, what this leads to in the end. Family
    > still holds a lot of pointers. But there are no objects at the
    > end of all those arrows. They have all been deleted.
    >
    > Well. Above I said: it has been wiped out of memory. Technically
    > this is impossible. Memory is memory. There is still memory at
    > all the end points of all those arrows and it is impossible for
    > memory to not hold some value. But logically those objects are no
    > longer there. The content of that memory is random and depends on a
    > lot of things outside your control. This is why the loop in your

    final
    > program outputs 0. It could have operated otherwise also. You program
    > could have simply crashed, because in the loop you take the pointer,
    > the arrow, follow it and tell the object at the end of the arrow
    > to give its age. But there is no object there any more!
    >
    >
    > --
    > Karl Heinz Buchegger
    >
    , Jan 26, 2005
    #6
  7. "" wrote:
    >
    > Dear Karl Heinz Buchegger,
    >
    > Thank you for your explanation. But if I understood you properly then
    > why does not the following code does not compile ?
    >
    > ----------
    >
    > int *p = new int[5];
    > int *p = new int[10];
    >


    Simple. Because you try to define 2 variables with the very same
    name. There really is no difference to

    int i = 0;
    int i = 5;

    After all, a pointer variable is just that: a variable.

    > -----------
    > But when I write the following code here below which seems to be the
    > same for me that I redeclare the pointer to point again to somewhere
    > else, the compiler does not complain. WHy?? Do I have memory leak in
    > any of these cases ?
    > ---------------
    > for (int i = 1; i<10; i++)
    > {
    > int *p = new int;
    > }
    > ---------------
    >


    Because here the lifetime of the variable p is the block under the for
    loop. So whenever the loop is restarted, all variables declared inside
    the loop are destroyed and get created again in the next loop repetition.

    Look up: lifetime of variables. Basically it says: Whenever a '}' is reached
    all variables declared in the corresponding block get destroyed.

    And yes, the above would be a memory leak.

    --
    Karl Heinz Buchegger
    Karl Heinz Buchegger, Jan 26, 2005
    #7
  8. On Wed, 26 Jan 2005 16:43:34 +0100, Gernot Frisch <> wrote:

    >> which only shows once more that these 21-day books are not sooo good
    >> (i know three of them)...

    >
    > I did the C in 21 days in 5 days and it was good.


    exactly. was good for your first 5 days of programming.

    as long as one follows the book's examples, everything is fine. as soon as
    you leave the tracks or want / need to know more, you're lost.

    just imho, and formulated a bit exaggerated.

    --
    have a nice day
    ulrich
    Ulrich Achleitner, Jan 26, 2005
    #8
  9. "Karl Heinz Buchegger" <> schrieb im Newsbeitrag
    news:...
    > "" wrote:
    >>
    >> Dear Karl Heinz Buchegger,
    >>
    >> Thank you for your explanation. But if I understood you properly
    >> then
    >> why does not the following code does not compile ?
    >>
    >> ----------
    >>
    >> int *p = new int[5];
    >> int *p = new int[10];


    This compiles:
    int* p=new int[5];
    p=new int[10];
    Forget about ever getting a chance for delete-ing the int[5] from now
    on - you have a memory leak.
    However, this is OK:

    int*p, *q;
    p = new int[5]; q=p;
    p = new int[10];

    delete [] p; // [10]
    delete [] q; // [5]

    -Gernot
    Gernot Frisch, Jan 27, 2005
    #9
  10. wrote:

    > Hello All,
    > I am learning C++ at the moment. Going through the book of SAM of
    > learning C++ in 21 days I have learned about pointers that it is good
    > custome to always initialise them and to use delete before you try to
    > give it a new address.


    Others have answered why it broke: what you have learned here is that
    SAMs books are an ok introduction to the language, but you will not know
    it until you have read some better books. C++ in 21 days will only give
    you a rough understanding of what's going on. I don't think it has
    anything blatantly wrong in it, though.

    --
    Will Twentyman
    email: wtwentyman at copper dot net
    Will Twentyman, Jan 27, 2005
    #10
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Phil
    Replies:
    1
    Views:
    644
    llewelly
    Sep 16, 2003
  2. muser
    Replies:
    3
    Views:
    760
    Ron Natalie
    Sep 18, 2003
  3. A
    Replies:
    3
    Views:
    455
    Alan Kelon
    Oct 29, 2003
  4. Chad

    pointers to pointers question

    Chad, Mar 26, 2006, in forum: C Programming
    Replies:
    5
    Views:
    312
    Default User
    Mar 27, 2006
  5. cerr

    pointers, pointers, pointers...

    cerr, Apr 7, 2011, in forum: C Programming
    Replies:
    12
    Views:
    672
Loading...

Share This Page