Thread: No change effect

This looks like an unallocated pointer to me (just like it would be in C++):

Originally Posted by onako

Code:

GenGraph* g; // this is from external lib, and declaration without * is 
                    // not allowed (at least, in my opinion)

Why, in your opinion, is it not be allowed? Presuming GenGraph really is a sort of struct, you need either:

Code:

GenGraph *g = malloc(sizeof(GenGraph));  // heap allocation
 -- OR --
GenGraph g;  // locally scoped stack allocation

If you want to pass the second one to myFunc, use the address of operator:

Code:

myFunc(&g);

How could I make the change in myFunc take effect?

There is no difference between C and C++ in this regard; the change should have taken effect. There is, however, a problem in myFunc() which should result in a compiler error (ie, this code should not compile):

Code:

void myFunc(GenGraph* g) {
     g.opt=1;
}

You are using direct notation with a pointer, which requires indirect notation:

Code:

g->opt=1;

Again, this is the same in C as it is C++. Here's three guesses as to the cause of your problem:

1) Because the original *g is just a pointer to a struct, not a struct, and you did not allocate any memory to it.
2) Because after you wrote myFunc(), your code no longer compiled because of the error, and you are running an executable compiled earlier from different code. Pay attention to the compiler, it is your friend.
3) GenGraph is not really a struct type (eg, it may be a typedef'd pointer, in which case you should get various warnings and/or further errors).

Thanks for the message. Bellow is the struct content:

Code:

http://www.graphviz.org/pub/graphviz/development/doxygen/html/graph_8h_source.html#l00060

Using

Code:

void myFunct( Agraph_t * g) {
    
    FILE *fp;
    /* say there is some fileName*/
    fp=fopen(fileName.c_str(), "r");
    g=agread(fp);
}
int main() {    
   Agraph_t* g;
   myFunct(g);
   Agnode_t *n=agfstnode(g);
}

everything compiles, but the change of g=agread(fp) does not take effect.
Changing as proposed,

Code:

Agraph_t g;
myFunct(&g);

results the following error message:

Code:

error: cannot convert ‘Agraph_t’ to ‘Agraph_t*’ for argument ‘1’ to ‘Agnode_t* agfstnode(Agraph_t*)’

So, the function agfstnode (from external library, as is Agraph_t) requires Agraph_t* as an argument. That was the reason for using it primarily.

Setting

Code:

 Agnode_t *n=agfstnode(&g);

does compile, but the execution terminates at this point.

Some thoughts?

Originally Posted by onako

everything compiles, but the change of g=agread(fp) does not take effect.

As KCfromNC hints, this:

Code:

g->opt = 1;

is significantly different from:

Code:

g = whatever...

The first is assigning a value to a member of the struct pointed to by g, but the second re-assigns g locally to something else. If you want to do something like that, myFunc would need a prototype like:

Code:

void myFunct( Agraph_t **g);

Ie, you'd need a pointer to a pointer (**), then you can dereference that and the assignment will not just be local:

Code:

*g = whatever;

This is exactly the same as if you were trying to pass an int value in for assignment:

Code:

void myFunc (int *n) {
    *n = 666;
}
int x;
myFunc(&x); 
// x is now 666

Changing as proposed,

Code:

Agraph_t g;
myFunct(&g);

results the following error message:

Code:

error: cannot convert ‘Agraph_t’ to ‘Agraph_t*’ for argument ‘1’ to ‘Agnode_t* agfstnode(Agraph_t*)’

As KCfromNC also hints, this error does not match with the code you've quoted; the function name is different. Don't paraphrase, quote the actual code you are really using. Otherwise, it is hard to say what the problem really is.

So, the function agfstnode (from external library, as is Agraph_t) requires Agraph_t* as an argument. That was the reason for using it primarily.

Okay:

Code:

void agfstnode(Agraph_t*)
Agraph_t mygraph;
agfstnode(&mygraph);

"&mygraph" is a Agraph_t* (it's the address of an Agraph_t), so if everything is as you say, this should not result in an error.

Setting

Code:

 Agnode_t *n=agfstnode(&g);

does compile, but the execution terminates at this point.

How do you know that is where the execution terminates, and how does it terminate?