[zeroibis]

I wanted to get a better understanding of using inheritance across methods.

For example can I make a set of stocks like:

stock methodA()
{
new X;
new Y;
methodB(X, Y);
return X+Y;
}

stock methodB(X, Y)
{
X = 1;
Y = 1;
}

The above should output 0 for methodA. How do I make it so that methodB can inherit the variables from methodA and modify them so that the output of methodA will be 2? Or is this not possible in pawn?

[xf117]

There is no Inheritance here. Cells are passed by value, so in your case they won't be modified.
Use stock methodB(&X, &Y)
This should work, i think...

[zeroibis]

Oh wait so if I use &X it will then inherit!?

[zeroibis]

What confuses me is that I have seen method like this:

/**
 * Fills an array with a given value in a 1 dimensional static array.
 * You can specify the amount of cells to be written.
 *
 * @param array            Static Array.
 * @param size            Number of cells to write (eg. the array's size)
 * @param value            Fill value.
 * @param start            Optional: Offset where to start (0 - (size-1)).
 * @noreturn
 */
stock Array_Fill(any:array[], size, any:value, start=0)
{
    if (start < 0) {
        start = 0;
    }

    for (new i=start; i < size; i++) {
        array[i] = value;
    }
}

Is it just able to work with an array b/c of the variable type it is?

Using any, any:y does not work as expected.

[xf117]

Arrays and Strings are passed by reference -> they are mutable. Any: basically means it can be almost any type, cell or float in this case.
It's good idea not to use it, really. There are few uses when you really need it.

[11530]

any: should not be used in that way. To answer your question, arrays are automatically passed by reference. Also, passing by reference is not called "inheritance" - that is something unrelated to SourcePawn.

[necavi]

In fact, if I remember correctly from poking around sourcecode, all &<variable> does is basically create an array of size 1, and then pass it through array passing mechanisms.

[asherkin]

Originally Posted by necavi In fact, if I remember correctly from poking around sourcecode, all &<variable> does is basically create an array of size 1, and then pass it through array passing mechanisms.

That would be a sane implementation.

[zeroibis]

Ah ok so that explains everything I was trying to wonder why it appeared that only arrays would work. Also thanks for the info on the & as I now understand what that does and why it works.

BTW was there a doc sheet anywhere that I missed that explained these things in detail or did this stuff just fly over my head due to lack of general programing knowledge?

Also thanks the & works perfect and does exactly what I needed. Hooray for less duplicate code!

[BAILOPAN]

The implementation of & works the same way it does in C, it passes the address that contains the variable (in the compiler internals its storage class is "iREFERENCE", rather than iARRAY or iVARIABLE).