Thread: Shortening the code

I have a frw hundred lines of code which looks like this

Code:

   case 0x0114:
   {
	struct DisplayNotifyMessage ptr;
	memcpy((void*)&ptr,s->receivebuffer,sizeof(struct DisplayNotifyMessage));
	#ifdef DEBUG
	ptr.m.display();
	ptr.display();
				#endif
	
	break;
   }
   case 0x0115:
   {
	struct ClearNotifyMessage ptr;
	memcpy((void*)&ptr,s->receivebuffer,sizeof(struct ClearNotifyMessage));
	
	#ifdef DEBUG
	ptr.m.display();
	ptr.display();
				#endif
	
	break;
   }
   case 0x0116:
   {
	struct ActivateCallplaneMessage ptr;
	memcpy((void*)&ptr,s->receivebuffer,sizeof(struct ActivateCallplaneMessage));
	
	#ifdef DEBUG
	ptr.m.display();
	ptr.display();
				#endif
	
	break;
   }

is there some way i can shorten it... since most of the parts are similar execpt that the structure is different..... please advice

why not just write one function then pass the struct as one as the args

See if you can declare a macro in place of the
#ifdef and #endif

and use that macro.

-Harsha.

HI since you are not checking the condition of #else or #elseif.. why dont you do...

Code:

#ifdef DEBUG
 switch(whatever)
 {
     case 0x114:
          struct whatever *ptr;
          memcpy(......);
          break;
     case 0x115:
          struct whatever *ptr;
          memcpy(......);
          break;
        ...
        ...
}
ptr.m.display();
ptr.display();
...
...

since by the time the control reached the end of switch statement, the ptr is still valid.

-Harsha.

actully now that i think about it why not use a struct that declares an instance of your other structs then pass that struct with the one that you wish to use in a function that does your memcopy and so on. I don't know if i explained that well maybe this will help

Code:

#include <stdio.h>

struct loser
{
  int power;
};
struct brian
{
  loser whatever;
};  

void setPower(brian &something);

int main()
{
  brian me;
  setPower(me);
  printf("Power: %i",me.whatever.power);
  getchar();  
}

void setPower(brian &something)
{
  something.whatever.power=10;
}

Before I suggest anything:

You seem to be copying function pointers from receivebuffer to the destination struct. How does this work?

Could you post an example definition for one of the structs?

The code you posted only copies a struct and calls a "common" (same signature) function pointer. It is possible that you may be able to get rid of the switch construct if this is really all you need to do. However, if your actual program needs to run different code depending on the message you may need the switch anyway.

The simplest way to reduce your source code lines while keeping your code exactly the same would be a simple text replacement macro:

Code:

   case 0x0114:
   {
	COMMON_MESSAGE_CODE(DisplayNotifyMessage);
        
	// Other code specific to this message.
   }

   case 0x0115:
   {
	COMMON_MESSAGE_CODE(ClearNotifyMessage);
        
	// Other code specific to this message.
   }

Originally Posted by vsriharsha

HI since you are not checking the condition of #else or #elseif.. why dont you do...

Code:

#ifdef DEBUG
switch(whatever)
{
case 0x114:
struct whatever *ptr;
memcpy(......);
break;
case 0x115:
struct whatever *ptr;
memcpy(......);
break;
...
...
}
ptr.m.display();
ptr.display();
...
...

since by the time the control reached the end of switch statement, the ptr is still valid.

-Harsha.

nope i dontt think ptr is still valid as it is out of scope... and i cant make it global since i dont know what type of struct ptr will be pointing to..

Originally Posted by Laserve

Here's another lame idea

Code:

void func(int x)
{
A a; B b; C c;
 
struct {
void *p;
size_t size;
} Structs[] = {
{ &a, sizeof(A) },
{ &b, sizeof(B) },
{ &c, sizeof(C) }
};
 
memcpy(Structs[x%3].p, " ", Structs[x%3].size);
}

that would solve a part of my problem.. but what abt calling the function display.. i cant do p->display() since p is a void pointer.....

Code:

union foo
{
    struct DisplayNotifyMessage d;
    struct ClearNotifyMessage c;
    struct ActivateCallplaneMessage a;
} bar;

...

    case 0x0114:
    {
        memcpy( &bar.d, s->receivebuffer, sizeof( bar.d ) );
#ifdef DEBUG
        bar.d.m.display();
        bar.d.display();
#endif
        break;
    }
    case 0x0115:
    {
        memcpy( &bar.d, s->receivebuffer , sizeof( bar.c ) );
#ifdef DEBUG
        bar.c.m.display();
        bar.c.display();
#endif
        break;
    }
    case 0x0116:
    {
        memcpy( &bar.a, s->receivebuffer, sizeof( bar.a ) );
#ifdef DEBUG
        bar.a.m.display();
        bar.a.display();
#endif
        break;
    }

[edit]
Or wrap the union inside a structure, and have your debug portion in the structure,
then access the union member as needed.
[/edit]

Quzah.

Originally Posted by quzah

Code:

union foo
{
    struct DisplayNotifyMessage d;
    struct ClearNotifyMessage c;
    struct ActivateCallplaneMessage a;
} bar;

...

    case 0x0114:
    {
        memcpy( &bar.d, s->receivebuffer, sizeof( bar.d ) );
#ifdef DEBUG
        bar.d.m.display();
        bar.d.display();
#endif
        break;
    }
    case 0x0115:
    {
        memcpy( &bar.d, s->receivebuffer , sizeof( bar.c ) );
#ifdef DEBUG
        bar.c.m.display();
        bar.c.display();
#endif
        break;
    }
    case 0x0116:
    {
        memcpy( &bar.a, s->receivebuffer, sizeof( bar.a ) );
#ifdef DEBUG
        bar.a.m.display();
        bar.a.display();
#endif
        break;
    }

But this will not reduce the code significantly, will it?

Originally Posted by quzah

[edit]
Or wrap the union inside a structure, and have your debug portion in the structure,
then access the union member as needed.
[/edit]
Quzah.

This should.

-Harsha