class question - please help

[Roger]

Can anyone tell me what is the difference between these two?

class nodeType
{
int data;
nodeType *link;
};

This is the first one:

main()
{
nodeType *test;
test->data=10;
cout << nodeType->data; // 10
}

and this is the second one:

main()
{
nodeType *test=new nodeType;
test->data=10;
cout << test->data; // 10
}

I am kind of confused because the first one was given by my instructor.
How is the memory allocated in the first situation?? Is there any
benefit or drawback of not using dynamic memory allocation??

Thanks in advance.

[Dave]

"Roger" <gn****@hotmail .com> wrote in message
news:xg******** ***********@nwr ddc02.gnilink.n et...

Can anyone tell me what is the difference between these two?

class nodeType
{
int data;
nodeType *link;
};

This is the first one:

main()
{
nodeType *test;
test->data=10;
cout << nodeType->data; // 10
}

and this is the second one:

main()
{
nodeType *test=new nodeType;
test->data=10;
cout << test->data; // 10
}

I am kind of confused because the first one was given by my instructor.
How is the memory allocated in the first situation?? Is there any
benefit or drawback of not using dynamic memory allocation??

Thanks in advance.

Well, looks like your instructor made a blunder in the first case! Until a
pointer points at something, it *can't* be used!

[Roger]

Dave wrote:

"Roger" <gn****@hotmail .com> wrote in message
news:xg******** ***********@nwr ddc02.gnilink.n et...

Can anyone tell me what is the difference between these two?

class nodeType
{
int data;
nodeType *link;
};

This is the first one:

main()
{
nodeType *test;
test->data=10;
cout << nodeType->data; // 10
}

and this is the second one:

main()
{
nodeType *test=new nodeType;
test->data=10;
cout << test->data; // 10
}

I am kind of confused because the first one was given by my instructor.
How is the memory allocated in the first situation?? Is there any
benefit or drawback of not using dynamic memory allocation??

Thanks in advance.

Well, looks like your instructor made a blunder in the first case! Until a
pointer points at something, it *can't* be used!

At first I also thought about that way. But after I compiled the
program, no error was found and the reasult print out successfully.
I am wondering why this happened??

[Alf P. Steinbach]

On Mon, 20 Oct 2003 21:16:46 -0700, "Dave" <be***********@ yahoo.com> wrote:

"Roger" <gn****@hotmail .com> wrote in message
news:xg******* ************@nw rddc02.gnilink. net...

Can anyone tell me what is the difference between these two?

class nodeType
{
int data;
nodeType *link;
};

This is the first one:

main()
{
nodeType *test;
test->data=10;
cout << nodeType->data; // 10
}

and this is the second one:

main()
{
nodeType *test=new nodeType;
test->data=10;
cout << test->data; // 10
}

I am kind of confused because the first one was given by my instructor.
How is the memory allocated in the first situation?? Is there any
benefit or drawback of not using dynamic memory allocation??

Thanks in advance.

Well, looks like your instructor made a blunder in the first case! Until a
pointer points at something, it *can't* be used!

He or she made at least five blunders, _assuming_ the code was not
meant to illustrate the following defects:

1) There's nothing accessible in that class.
2) Illegal declaration of 'main'.
3) Forgetting to allocate an object.
4) Forgetting to include <iostream>
5) Forgetting to output a logical newline at the end.

But how do we know this question isn't homework in disguise, "find 5
defects in the following code"?

[David White]

Roger <gn****@hotmail .com> wrote in message
news:xg******** ***********@nwr ddc02.gnilink.n et...

Can anyone tell me what is the difference between these two?

class nodeType
{
int data;
nodeType *link;
};

This is the first one:

main()
{
nodeType *test;
test->data=10;
cout << nodeType->data; // 10
}

and this is the second one:

main()
{
nodeType *test=new nodeType;
test->data=10;
cout << test->data; // 10
delete test;
}

I am kind of confused because the first one was given by my instructor.
How is the memory allocated in the first situation??
It's not. It's a bug serious enough to crash a program, or, worse, keep
running but with undefined behaviour that you might or might not notice.
Is there any
benefit or drawback of not using dynamic memory allocation??

If you want to be sure your program will work, your pointer _has_ to point
to a real object before you dereference it, whether it be dynamically,
statically or automatically allocated.

DW

[Josh Lessard]

On Tue, 21 Oct 2003, Roger wrote:

Can anyone tell me what is the difference between these two?

class nodeType
{
int data;
nodeType *link;
};

This is the first one:

main()
{
nodeType *test;
test->data=10;
cout << nodeType->data; // 10
}

and this is the second one:

main()
{
nodeType *test=new nodeType;
test->data=10;
cout << test->data; // 10
}

I am kind of confused because the first one was given by my instructor.
How is the memory allocated in the first situation?? Is there any
benefit or drawback of not using dynamic memory allocation??

You're correct in being confused. The first example won't work at all.
You have a pointer to nodeType, but it doesn't point at anything. If
you're lucky, it will crash...if you're not, it will produce nonsensical
results. If your instructor was trying to show you an automatic variable
(which is allocated on the system stack), he should have given something
like this:

int main()
{
nodeType test;
test.data=10;
cout << nodeType.data; // 10
}

Also, your instructor is giving you nonstandard C++ code. The main
function must always be defined with a return type of int. (ie, int
main() instead of main() ).

*************** *************** *************** ********
Josh Lessard
Master's Student
School of Computer Science
Faculty of Mathematics
University of Waterloo
[phone] x3400
http://www.cs.uwaterloo.ca
*************** *************** *************** ********

[Dave]

"Roger" <gn****@hotmail .com> wrote in message
news:Kw******** ***********@nwr ddc01.gnilink.n et...

Dave wrote:

"Roger" <gn****@hotmail .com> wrote in message
news:xg******** ***********@nwr ddc02.gnilink.n et...

Can anyone tell me what is the difference between these two?

class nodeType
{
int data;
nodeType *link;
};

This is the first one:

main()
{
nodeType *test;
test->data=10;
cout << nodeType->data; // 10
}

and this is the second one:

main()
{
nodeType *test=new nodeType;
test->data=10;
cout << test->data; // 10
}

I am kind of confused because the first one was given by my instructor.
How is the memory allocated in the first situation?? Is there any
benefit or drawback of not using dynamic memory allocation??

Thanks in advance.

Well, looks like your instructor made a blunder in the first case! Until a pointer points at something, it *can't* be used!

At first I also thought about that way. But after I compiled the
program, no error was found and the reasult print out successfully.
I am wondering why this happened??

It worked purely by serendipity. Believe it, this is a bad program and it
cannot be relied on, even if it seems to work at times!

[Roger]

like this:

int main()
{
nodeType test;
test.data=10;
cout << nodeType.data; // 10
}

Also, your instructor is giving you nonstandard C++ code. The main
function must always be defined with a return type of int. (ie, int
main() instead of main() ).

Sorry, that was my mistake. and I did not put #include <iostream> and
using namespace std; Actually my instructor used void main().
However, the odd thing was that I could compile the source code without
any error and the output was right. ???

It's amazing how fast you can get your answer in a newsgroup.

[Dave]

"Dave" <be***********@ yahoo.com> wrote in message
news:cM2lb.6136 3$La.30402@fed1 read02...

"Roger" <gn****@hotmail .com> wrote in message
news:Kw******** ***********@nwr ddc01.gnilink.n et...

Dave wrote:

"Roger" <gn****@hotmail .com> wrote in message
news:xg******** ***********@nwr ddc02.gnilink.n et...

>Can anyone tell me what is the difference between these two?
>
>class nodeType
>{
> int data;
> nodeType *link;
>};
>
>This is the first one:
>
>main()
>{
> nodeType *test;
> test->data=10;
> cout << nodeType->data; // 10
>}
>
>and this is the second one:
>
>main()
>{
> nodeType *test=new nodeType;
> test->data=10;
> cout << test->data; // 10
>}
>
>I am kind of confused because the first one was given by my instructor.>How is the memory allocated in the first situation?? Is there any
>benefit or drawback of not using dynamic memory allocation??
>
>Thanks in advance.
>
Well, looks like your instructor made a blunder in the first case! Until a pointer points at something, it *can't* be used!

At first I also thought about that way. But after I compiled the
program, no error was found and the reasult print out successfully.
I am wondering why this happened??

It worked purely by serendipity. Believe it, this is a bad program and it
cannot be relied on, even if it seems to work at times!

And as a second note, it's not surprising it compiled OK with regard to the
pointer error. That part of the program is syntactically legal, it's just
not semantically legal (again, you can't use a pointer that doesn't point at
anything; but the compiler cannot detect that in the general case at compile
time). Of course, as Alf pointed out, there are other problems besides the
pointer problem which the compiler should have balked at...

[David White]

Roger <gn****@hotmail .com> wrote in message
news:gR******** ***********@nwr ddc01.gnilink.n et...

Actually my instructor used void main().
Try and find another instructor.
However, the odd thing was that I could compile the source code without
any error and the output was right. ???
It worked by accident. That's all. The pointer just happened to point to a
writable/readable address in memory that, apparently, didn't cause any
damage or misbehaviour when accessed in your program.

It's amazing how fast you can get your answer in a newsgroup.

We try to please.

DW