posted                   

code:

---

void Subtract (int &i, int &j)
{
   if (i > j) i -= j;
   else j -= i;
}

int main (...)
{
   int k = 20;
   int m = 10;
   cout << k << "  " << m << endl << endl;
   Subtract(k, m);
   cout << k << "  " << m << endl << endl;
   m = 40;
   Subtract(k, m);
   cout << k << "  " << m << endl;
}

---

The output would be:
20 10

10 10

10 30


Because when you declare a function with arguments using the & symbol, you're telling it to point to the memory address of the supplied argument. So in this case, instead of creating a variable to be modified by the function, you are instead using a pointer to modify a local variable in a different function.

If you were to declare the function without using the & symbol for the arguments, then you'd simply be assigning values to i and j themselves, rather than using i and j to manipulate k and m.

Once I learned how to use Pointers correctly and I started looking for more examples, I began to realise exactly how useful they are .

posted                       

code:

---

 do {
	printf("=> Choose an option: USE [1] DEL [2] EXT [3] \n");
	scanf("%d",&opution);
	if (opution == 1){ LOADKYARA();}	
	else if (opution == 2){ DELKYARA(); }
	else if (opution == 3){ 
		printf("Logging off... \n");
		return 0;
		}
	} while(opution>=4 || opution<=0); 
} // End Login Module 

---

posted                       

code:

---

fooByPointer( int *a )
{
  *a = *a + 1;
}

fooByReference( int &a )
{
  a = a + 1;
}

fooNoChange( int a )
{
  a = a + 1;  // only a local copy of a is changed.
}

foo()
{
  int num = 3;

  fooByReference( num );  // on return num is 4
  fooByPointer( &num ); // on return num is 5
  fooNoChange( num ); // on return num is still 5
}

---

code:

---

fooSomeFunction( Object* obj)
{
   // I wonder if i should put up a menu selection
   // by which you could take a bite out
   // of this object?
   // Does it have the 'eatable' interface?
   InterfaceEatable *pEatable = object->eatableIf();
   if( pEatable ) {
     // It has an eatable interface
     int bitesLeft = pEatable->numBitesLeft();
     bool rotten = pEatable->isRotten();
     if( bitesLeft > 0 && !rotten ) {
       // Looks juicy!
       AddMenuSelection( "Take a bite of me" );
     }
   }
   else
   {
     // nope, cannot be eaten, no menu needed
   }
}

---

How you actually query an object pointer to see if it has an interface is up to you. Windows has its own QueryInterface metaphor which I resisted for years (and we implemented our own system at work -- we have to work in windows and linux). Anyway, I like the metaphor, when I am making some new sort of object, that I just have it offer a handful of interfaces that describe what sorts of relationships the user may have with the object. Plus you make aome helper classes which make the actual implementation of interfaces not have much code duplication. Everyone wins. The code also ends up kinda readable, and broken into nice digestible chunks.

So long as you come up with good names, which is hard for me. For example, in Philbert's example (I paraphrase):

Calculator compute; // 'compute' is an 'instance' of class 'Calculator'

Adding the word 'compute' to the mix just takes you away from the original focus. This is the sort of thing I do all the time and regret. I think it's better to stay closer like

Calculator calc;

or

Calculator myCalculator

or, if I were any good at it, I could give a good example. I just know that when I rename things at every level of the chain, pretty soon you get down deep and no longer are sure what anything is any more.

Coming up with clear and accurate (and short, and unique, and metaphorically satisfying) names for things is an amazing programming skill to have, and a real struggle for me, even now, though I think I have gotten a *little* better at it through the years.

For example, here is today's failure:

code:

---

   local result, modifiedPayload = RC_ActionTargetsSpawn( mySerNum, clientStarId, 
                                       actionSerNum, actionIndex,
                                       srcStarId, srcStarIndex, 
                                       tgtStarId, tgtStarIndex, 
                                       payload )

---

code:

---

function RC_OnActionButton( 
         step, mySerNum, clientStarId,
         actionSerNum, actionIndex,
         srcStarId, srcStarIndex,
         tgtStarId, tgtStarIndex )

---

code:

---

function RC_OnActionRequest( 
         step, mySerNum, clientStarId,
         actionSerNum, actionIndex,
         srcStarId, srcStarIndex,
         tgtStarId, tgtStarIndex,
         payload )

---

code:

---

function RC_OnActionResult( 
         step, mySerNum, clientStarId,
         actionSerNum, actionIndex,
         srcStarId, srcStarIndex,
         tgtStarId, tgtStarIndex,
         payload )

---

code:

---

function RC_OnActionStep( 
         step, mySerNum, clientStarId,
         actionSerNum, actionIndex,
         srcStarId, srcStarIndex,
         tgtStarId, tgtStarIndex,
         payload, stepNum, handle )

---

This is called on the CLIENT action script (on all clients who 'care') About 10x a second with an increasing step number (goes up by one each time the function is called)

The client script then looks at the step number and notices important moments in time like "right away I should start the particles, but about a second later I should make a little explosion, and 2 seconds after that I should apply the damage to the target and debit the mana from the caster, and ... etc."

So on each call it checks the step number, and only does a little bit of work and returns. The value it returns controls when the action is complete (afte which it is no longer stepped)

ANYWAY, I bring all that up, because today I added a notification FROM the 'action script' TO the 'hive script' (a completely separate script which is running the AI of the object/npc/monster). Basically I needed a function which indicates "hey, mister HAVE script, I, an ACTION script, have just beed targeted on one of your SPAWN."

This is used so, for example, if I am standing off some distance from the spawn of the hive, far enough away that they don't 'see' me (they don't consider me a 'threat') and then I shoot one of them.. this allows the hive to set my threat level, even though I am otherwise 'too far away to matter' by raising my threat level for some period of time (all under the control of the hive script). And presumably the hive AI will then tell that spawn that I am the biggest threat and it should run up and attack me.

Otherwise, I could just stand off and shoot from a distance without any fear, and what fun is that?

Anyway, so.. the ACTION script (on the server) calls this function (calls into C++)

code:

---

   local result, modifiedPayload = RC_ActionTargetsSpawn( mySerNum, clientStarId, 
                                       actionSerNum, actionIndex,
                                       srcStarId, srcStarIndex, 
                                       tgtStarId, tgtStarIndex, 
                                       payload )
 

---

code:

---

function RC_OnActionTargetsSpawn( spawnIndex, 
			casterSerNum, casterStarId, 
			actionSerNum, actionIndex,
			srcStarId, srcStarIndex, 
			tgtStarId, tgtStarIndex, 
			payload )

---

Same name, but with 'On' in it. Basically if the function has 'On' in it, the the c++ calls that function in response to an event, and there are relatively few of these.

RC_ without the 'on' means the lua script is calling into c++ to perform some service on its behalf (play a sound, change a stat value, test the state of a token, start an animation, etc.)

All functions, c++ or lua, return right away and do NOT spin wheels waiting for time to go by.

OK, well, that was a nice long unnecessary post.



--------------------
He knows when you are sleeping.

posted                       

code:

---

 void evaluate (char* expression)
{
    char first [256] = "";
    char last [256] = "";
    char result [256] = "";
    if (strchr(expression, '(') != NULL || strchr(expression, ')') != NULL) {
        int oparray [32]; //Open Parentheses
        int cparray [32]; //Close Parentheses
        int opcount = 0;
        int cpcount = 0;
        for (int i=0; i<=strlen(expression); i++) {
            switch (expression[i]) {
                case '(':
                    opcount++;
                    oparray[opcount] = i;
                    break;
                case ')':
                    cpcount++;
                    cparray[cpcount] = i;
                    break;
            }
        }
        if (opcount < cpcount) {
            printf("Error; unexpected close parenthesis!\n"); expression = "(null)"; return;
        } else if (opcount > cpcount) {
            printf("Error; missing close parenthesis!\n"); expression = "(null)"; return;
        } else if (oparray[opcount] > cparray[cpcount] || oparray[1] > cparray[1]) {
            printf("Error; mismatched parentheses!"); expression = "(null)"; return;
        } else {
            for (int i=opcount; i>0; i--) {
                char inputstring [256];
                char outputstring [256];
                strncpy(inputstring, &expression[oparray[i]+1], strcspn(&expression[oparray[i]+1], ")"));
                inputstring[strcspn(&expression[oparray[i]+1], ")")] = '\0';
                memset(first, 0, 256);
                strncpy(first, expression, oparray[i]);
                strcpy(last, &expression[oparray[i]+strcspn(&expression[oparray[i]+1], ")")+2]); //+2 gets us past both parentheses.  Weird stuff.
                evaluate(inputstring);
                memcpy(expression, first, 255);
                strcat(expression, inputstring);
                strcat(expression, last);
            }
        }
    }
    if (strchr(expression, '{') != NULL || strchr(expression, '}') != NULL || strchr(expression, '^') != NULL) {
        printf("No support for this function yet!\n");
        return;
    }
    if (strchr(expression, '*') != NULL || strchr(expression, '/') != NULL) {
        int j = strlen(expression);
        int expindex = 0; //the index to read the first argument from
        int symbindex = 0; //the index of the symbol
        double a = 0; //first value
        double b = 0; //second value
        char* lastptr;
        for (int i = 0; i<=strlen(expression); i++) {
            switch (expression[i]) {
                case '*':
                    memset(first, 0, 256);
                    memset(result, 0, 256);
                    memset(last, 0, 256); 
                    symbindex = i;
                    a = atof(&expression[expindex]);
                    b = strtod(&expression[symbindex+1], &lastptr);
                    a *= b;
                    i++;
                    strncpy(first, expression, expindex);
                    memcpy(last, lastptr, 255);
                    memcpy(expression, first, 255);
                    sprintf(result, "%f", a);
                    strcat(expression, result);
                    strcat(expression, last);
                    expression[strlen(expression)] = '\0';
                    j = strlen(expression);
                    i = strlen(first) + strlen(result) - 1;
                    expindex = strlen(first);
                    break;
                case '/':
                    memset(first, 0, 256);
                    memset(result, 0, 256);
                    memset(last, 0, 256);
                    symbindex = i;
                    a = atof(&expression[expindex]);
                    b = strtod(&expression[symbindex+1], &lastptr);
                    a /= b;
                    i++;
                    strncpy(first, expression, expindex);
                    memcpy(last, lastptr, 255);
                    memcpy(expression, first, 255);
                    sprintf(result, "%f", a);
                    strcat(expression, result);
                    strcat(expression, last);
                    expression[strlen(expression)] = '\0';
                    j = strlen(expression);
                    i = strlen(first) + strlen(result) - 1;
                    expindex = strlen(first);
                    break;
                case '+':
                case '-':
                    expindex = i; expindex++;
                    break;
                default:
                    break;
            }
        }
    }
    if (strchr(expression, '*') != NULL || strchr(expression, '/') != NULL) {
        int j = strlen(expression);
        int expindex = 0; //the index to read the first argument from
        int symbindex = 0; //the index of the symbol
        double a = 0; //first value
        double b = 0; //second value
        char* lastptr;
        for (int i = 0; i<=strlen(expression); i++) {
            switch (expression[i]) {
                case '+':
                    memset(first, 0, 256);
                    memset(result, 0, 256);
                    memset(last, 0, 256); 
                    symbindex = i;
                    a = atof(&expression[expindex]);
                    b = strtod(&expression[symbindex+1], &lastptr);
                    a += b;
                    i++;
                    strncpy(first, expression, expindex);
                    memcpy(last, lastptr, 255);
                    memcpy(expression, first, 255);
                    sprintf(result, "%f", a);
                    strcat(expression, result);
                    strcat(expression, last);
                    expression[strlen(expression)] = '\0';
                    j = strlen(expression);
                    i = strlen(first) + strlen(result) - 1;
                    expindex = strlen(first);
                    break;
                case '-':
                    memset(first, 0, 256);
                    memset(result, 0, 256);
                    memset(last, 0, 256);
                    symbindex = i;
                    a = atof(&expression[expindex]);
                    b = strtod(&expression[symbindex+1], &lastptr);
                    a -= b;
                    i++;
                    strncpy(first, expression, expindex);
                    memcpy(last, lastptr, 255);
                    memcpy(expression, first, 255);
                    sprintf(result, "%f", a);
                    strcat(expression, result);
                    strcat(expression, last);
                    expression[strlen(expression)] = '\0';
                    j = strlen(expression);
                    i = strlen(first) + strlen(result) - 1;
                    expindex = strlen(first);
                    break;
                default:
                    break;
            }
        }
    }
    return;
} 

---

posted                       

code:

---

// eval.cpp

#include "stdafx.h"

//
// OK, at least once in my life I have to write a simple expression evaluator
//
// IN:  ( ( a * b ) + c ) / ( d / (e * f + g ) - 4 )
// (only no letters, just numbers
// out: the value
//
// The theory, there are keyword operators
//
// * / + -   (evaluated with that precedence)
//
// and parens
//
// 1.) scan the input and turn it into a list of eTerms
//     an eTerm is either a number (a float) or an operator or a paren
//     We scan to convert number strings to floats and detect keywords and remove syntax sugar
//
// 2.) then we process the resuling list if eTerms
//
// 3.) when we have an expression fragment with 'no inner parens' we evaluate it, turning
//     it into a simple number passed to the level above
//
// 4.) but if there is a (, we scan for the matching ) [watch out for nesting] and recursively evaluate that before continuing.

// Everything eventually resolves to a single floating point value.

//
// It's all about the data structure.  I will make
// a list of these out of whatever you give me
//
//
enum eTermType {
	eTermTypeVoid		= 0,
	eTermTypeNumber		= 1,
	eTermTypeOperator	= 2,
	eTermTypeLeftParen	= 3,
	eTermTypeRightParen = 4,
};

typedef struct E_TERM_ {
	eTermType type;
	char operatorId;	// '*' '/' '+' '-' if it is an operator
	float val;			// if a number, this is the value
} E_TERM;

#define MAX_E_TERMS	( 100 )

//
//
///////////////////
// ReduceTerms is always given a simple list (no parens) and a single operation to apply as found, left to right, in the list.
//
//

int ReduceTerms( char operatorId, E_TERM * evalList, int numTerms )
{
	// this scans the list from left to right
	// looks for only the specified operatorId
	// applies it to args to left and right of operator
	// shrinks the list by 2 (replacing first arg with result, removing operator and second arg)
	// We know this is only called on 'simple lists' with no parens
	int i;
	for( i=1; i<numTerms; i++ )
	{
		if( evalList[ i ].type == eTermTypeOperator
		 && evalList[ i ].operatorId == operatorId
		  )
		{
			// this is the operator we're looking for
			float arg1 = evalList[ i-1 ].val;
			float arg2 = evalList[ i+1 ].val;		// yes, I should check for actual term, but I know I won't segfault
													// and I didn't promise accuracy, given garbage in
			float result = 0;
			switch( operatorId ) {
				case '*':
					result = arg1 * arg2;
					break;
				case '/':
					if( arg2 == 0 ) {
						result = arg1;					// you're screwed no matter what, but no sense crashing the program
					} else {
						result = arg1 / arg2;			// I didn't promise to protect you from dividing by zero, but I will
					}
					break;
				case '+':
					result = arg1 + arg2;
					break;
				case '-':
					result = arg1 - arg2;
					break;
			}
			// ok, now collapse the list to remove this operation
			evalList[ i-1 ].val = result;
			int j;
			for( j=i; j<numTerms-1; j++ )
			{
				evalList[ j ] = evalList[ j + 2 ];
			}
			numTerms -= 2;
			i--;	// oddly enough, we need to reevalute from this spot to catch strings of matching opers "1 + 1 + 1 + 1"
		}
	}

	return numTerms;
}

//
//
//
///////////////////
// RecursiveEvaluation
//
// This is also given a sublist, but it may contain parens, which it will scan for, make a sublist of all the tokens 'inside the outermost parens' and recurse into itself
// Eventually it will get sublists with no parens which it can pass to ReduceTerms()
//
//

float RecursiveEvaluation( E_TERM * evalList, int first, int lastPlusOne )
{
	// evaluate the terms left to right, using precedence rules
	// () * / + -

	// so I think the way I will do this is by copying the terms
	// to the stack, and in this way I can convert an entire paren
	// section to a single numeric value
	E_TERM myEvalList[ MAX_E_TERMS ];		// stack could get pretty deep here, I am not claiming cleverness
	int numTerms = 0;
	int i;
	for( i=first; i<lastPlusOne; i++ )
	{
		E_TERM *pEin  = &(evalList[ i ]);				// next input term

		if( pEin->type == eTermTypeLeftParen ) {
			// find the matching right paren, and then recurse to
			// evaluate the paren'd structure and return it as a simple number
			if( i < lastPlusOne - 1 )	// ignore an open paren at the end of the list
			{
				E_TERM *pEout = &(myEvalList[ numTerms++ ]);	// allocate a symbol on my local list
				int j;
				int depth = 0;	// must deal with nested parens
				bool foundMatch = false;
				int rightParenIndex = lastPlusOne;		// if we don't FIND a matching eright paren, assume it is at end
				for( j=i+1; !foundMatch && j<lastPlusOne; j++ )
				{
					switch( evalList[ j ].type )
					{
					case eTermTypeLeftParen:
						// uh oh, went deeper
						depth++;
						break;
					case eTermTypeRightParen:
						if( depth == 0 ) {
							// this is the one we're looking for!
							foundMatch = true;
							rightParenIndex = j;
							break;
						}
						depth--;
						break;
					}
				}
				pEout->type = eTermTypeNumber;
				pEout->operatorId = 0;
				// this routine wants one past the index to be evaluated, so pointing to right paren itself is correct
				pEout->val = RecursiveEvaluation( evalList, i+1, rightParenIndex );		

				// adjust i to pick up after the right paren
				i = rightParenIndex;		// i will be incremented before we next use it
			}
		} else {
			// just copy it across
			E_TERM *pEout = &(myEvalList[ numTerms++ ]);	// allocate a symbol on my local list
			*pEout = *pEin;
		}
	}

	// now evaluate what I have in my own list, which is guaranteed to 
	// have no parens and just need precedence * / + -
	// And maybe something special for unary -

	// So..

	float result = 0;

    // Well, this is not very elegant, but I just call my little helper for each precedence
	numTerms = ReduceTerms( '*', myEvalList, numTerms );
	numTerms = ReduceTerms( '/', myEvalList, numTerms );
	numTerms = ReduceTerms( '+', myEvalList, numTerms );
	numTerms = ReduceTerms( '-', myEvalList, numTerms );
	if( numTerms > 0 ) {
		// should be exactly one, unless they got clever and gave us no numbers at all
		result = myEvalList[ 0 ].val;
	}
	return result;
}



//
//
//
///////////////////////////
// Evaluate( char * )
//
// Give me something like "34.5 / (1 + 23.4) - 45.6"
// and I will give you the answer. 
//
// I will first parse your input string into a list (an array) of eTerm structures.  And then I
// will recursively scan that list.
//

float Evaluate( const char *in )
{
	// first we 'lexically parse it' into a list of terms
	E_TERM myEvalList[ MAX_E_TERMS ];
	int numTerms = 0;
	float result = 0;
	numTerms = 0;
	do
	{
		E_TERM *pE = NULL;
		char numBuff[ 100 ] = "";
		int numOff = 0;
		while( *in && *in <= ' ' ) {
			// skip leading white space
			in++;
		}
		switch( *in )
		{
		case '*':	// multiply
		case '/':	// divide
		case '+':	// add
		case '-':	// subtract
			pE = &(myEvalList[ numTerms++ ]);	// allocate a symbo
			pE->type = eTermTypeOperator;
			pE->operatorId = *in++;
			pE->val = 0.0f;
			break;
		case '(':	// these could be operators, but it feels like it will simplify life later to have a type
			pE = &(myEvalList[ numTerms++ ]);	// allocate a symbo
			pE->type = eTermTypeLeftParen;
			pE->operatorId = *in++;
			pE->val = 0.0f;
			break;
		case ')':	// 
			pE = &(myEvalList[ numTerms++ ]);	// allocate a symbo
			pE->type = eTermTypeRightParen;
			pE->operatorId = *in++;
			pE->val = 0.0f;
			break;
		default:	// number or symbol, and since we don't allow symbols, it's a number!
			// at this point it simply should be a number, which 
			// means 0-9 and decimal point only. so we grab nothing but those

			while( *in									// not yet at end of string
				&& (numOff < 100)						// not yet overflowing number
				&& ( *in == '.'							// decimal point
				  || (*in >= '0' && *in <= '9')			// or decimal digit
				   ) 
				 )
			{
				numBuff[ numOff++ ] = *in++;
				numBuff[ numOff ] = 0;
			}
			if( numOff > 0 ) {
				pE = &(myEvalList[ numTerms++ ]);	// allocate a symbol
				pE->type = eTermTypeNumber;
				pE->operatorId = 0;
				pE->val = (float) atof( numBuff );		
			} else {
				// we got some junk, throw it away
				if( *in ) {
					in++;
				}
			}
			break;
		}
	} while ( *in && (numTerms < MAX_E_TERMS) );

	// OK, we have 'parsed' the input into a nice list, now we just evaluate the terms
	// recursively

	result = RecursiveEvaluation( myEvalList, 0, numTerms );	// evaluate the entire list

	return result;
}

---