using new in functions, pointers passed still NULL after called?!

[_ivan]

Hello,

So I think the answer to this question is going to be rather simple.

Basically I have a pointer to a class, and I want to have a function
to call to initialize it.

After this function is called, the pointer is still NULL.

Here is a simplified version, but basically the same:

void main(){
MyClass *ptr = NULL;
createMyClass(p tr);
}

createMyClass(M yClass *ptrToClass){
ptrToClass= new MyClass();
}

Any reason why ptr would still be NULL after createMyClass is called?

Thanks,
_ivan

[Ivan Vecerina]

Hi Ivan,

"_ivan" <ik***@nyu.ed u> wrote in message
news:f4******** *************** ***@posting.goo gle.com...
| void main(){
| MyClass *ptr = NULL;
| createMyClass(p tr);
| }
|
| createMyClass(M yClass *ptrToClass){
| ptrToClass= new MyClass();
| }
|
| Any reason why ptr would still be NULL after createMyClass is called?

By default in C/C++, function parameters *copies* of values
that are passed.

In the code above, changing the value of 'ptrToClass' will
not affect 'ptr' in main.

A way to achieve what you expect is to pass the parameter
by reference. What you need to do is change the function's
signature as follows:
createMyClass( MyClass*& ptrToClass )

This will behave as you expect...
hth
--
http://www.post1.com/~ivec <> Ivan Vecerina
http://www.brainbench.com <> Brainbench MVP for C++

[Mike Wahler]

_ivan <ik***@nyu.ed u> wrote in message
news:f4******** *************** ***@posting.goo gle.com...

Hello,

So I think the answer to this question is going to be rather simple.

Basically I have a pointer to a class, and I want to have a function
to call to initialize it.
A class type object should be initialized with a
constructor, not by calling a function after the fact.

After this function is called, the pointer is still NULL.

Here is a simplified version, but basically the same:

void main(){
int main() {
MyClass *ptr = NULL;
createMyClass(p tr);
}

createMyClass(M yClass *ptrToClass){
ptrToClass= new MyClass();
}

Any reason why ptr would still be NULL after createMyClass is called?
Yes. Look up 'pass by value' vs. 'pass by reference'.

#include <iostream>

class MyClass {};

void createMyClass(M yClass *&ptrToClass)
{
ptrToClass = new MyClass;
}

int main()
{
MyClass *ptr = 0;
std::cout << "Before: " << ptr << '\n';
createMyClass(p tr);
std::cout << "After : " << ptr << '\n';
delete ptr;
return 0;
}

But why not just create the object directly in main(),
and don't fool with 'new'.?

int main()
{
MyClass mc;
return 0;
}

Or if you must use 'new' for whatever reason, why not
just call it directly instead of making a separate
function?

int main()
{
MyClass *ptr = new MyClass;
/* etc */
delete ptr;
return 0;
}

-Mike
_ivan

[Ron Natalie]

"Ivan Vecerina" <iv**@myrealbox .com> wrote in message news:3f******** @news.swissonli ne.ch...

By default in C/C++, function parameters *copies* of values
that are passed.

With the exception of the apparent (but not in reality) passing of arrays.

[Hafiz Abid Qadeer]

"Mike Wahler" <mk******@mkwah ler.net> wrote in message news:<y1******* *******@newsrea d3.news.pas.ear thlink.net>...

_ivan <ik***@nyu.ed u> wrote in message
news:f4******** *************** ***@posting.goo gle.com...

Hello,

So I think the answer to this question is going to be rather simple.

Basically I have a pointer to a class, and I want to have a function
to call to initialize it.

A class type object should be initialized with a
constructor, not by calling a function after the fact.

After this function is called, the pointer is still NULL.

Here is a simplified version, but basically the same:

void main(){

int main() {

MyClass *ptr = NULL;
createMyClass(p tr);
}

createMyClass(M yClass *ptrToClass){
ptrToClass= new MyClass();
}

Any reason why ptr would still be NULL after createMyClass is called?

Yes. Look up 'pass by value' vs. 'pass by reference'.

#include <iostream>

class MyClass {};

void createMyClass(M yClass *&ptrToClass)
{
ptrToClass = new MyClass;
}

int main()
{
MyClass *ptr = 0;
std::cout << "Before: " << ptr << '\n';
createMyClass(p tr);
std::cout << "After : " << ptr << '\n';
delete ptr;
return 0;
}

But why not just create the object directly in main(),
and don't fool with 'new'.?

int main()
{
MyClass mc;
return 0;
}

Or if you must use 'new' for whatever reason, why not
just call it directly instead of making a separate
function?

int main()
{
MyClass *ptr = new MyClass;
/* etc */
delete ptr;
return 0;
}

-Mike

_ivan

You can also use the pointer to pointer like this
#include <iostream>
class MyClass
{
};

void createMyClass(M yClass **ptrToClass)
{
*ptrToClass= new MyClass();
std::cout<<"Val ue in Function:"<<*pt rToClass<<std:: endl;
}
int main()
{
MyClass *ptr = NULL;
createMyClass(& ptr);
std::cout<<"Val ue in main:"<<ptr<<st d::endl;
return 0;
}
in this way change reflects in the actual pointer when you return from the function.