End loop when empty/null value found

[mrapoc]

Hello

I'm looping through hex values

for (x = 0; x <=10; x++) //Ignore the x <=10 value 		{
			printf("\nThe Value of hex %x is: %i\n",*(hex+x), *(hex+x));
			printf("\nThe value of X is: %i\n", x);
			getchar();
		}

And I want it to stop when the test data is depleted

*hex = 0x0F; 	*(hex+1) = 0x11;
	*(hex+2) = 0xFF;
	*(hex+3) = 0x1B;
	*(hex+4) = 0x00;
	*(hex+5) = 0xB6;

How would I go about that? As 0x00 can actually be a value, I can't stop looping once 0x00 condition is met

Thanks

[laserlight]

When will the test data be "depleted"?

[ssharish2005]

For certain your question doesn't make much of sense thus far. Indeed you may be well assign hex value as you've shown above.

Are you asking that loop has to terminate when i == 0x00? If it is, then it not much of an expensive task to accomplish.

ssharish

[mrapoc]

Test data can be as big or as small.

I suppose my question would be, what value would I be looking to detect as a end loop requirement when I have not actually allocated a value to *(hex+x)

For example, I'd want the below to end at the equivalent of *(hex+6)

*(hex+2) = 0xFF;    *(hex+3) = 0x1B;
    *(hex+4) = 0x00;
    *(hex+5) = 0xB6;

Sorry I'm not making much sense, I'm pretty new to all this and other previous programming (minimal) seems to be confusing me too

[laserlight]

Okay, let's try another approach: how/where are you getting these "hex values"?

[mrapoc]

Its literally test data which I then later have to convert to a type of file. They can be anything (as long as its hex) as little or as small as required to carry out an example that it works

They are being inputted that way as thats how the lecturer deems the only correct way. Everything which i felt made sense prior to asking the lecturer for feedback seems to have been blown out the window!

Oh but the test data has to fit into 64k of memory

[laserlight]

They are being inputted that way as thats how the lecturer deems the only correct way.

You did not show how the input is read.

Generally, there are two ways to keep track of the length of a sequence: you either explicitly keep track of the length by having a variable to store the length, or you designate a special value to mark the end of the sequence. In this case, there are no special values, so there must be a variable that keeps track of the length of the sequence, e.g., this variable is modified when the input is read.

With this variable, looping over the hex values is easy: start from the beginning, then loop until you have reached the position denoted by the length.

[iMalc]

This question is like: I'm driving along the road, how do I know when I've reached my destination?
So we ask: What is your destimation?
And you answer: I'll know it when I see it.
This is why we haven't been able to help you yet.

Just show more code. Code speaks for itself.

[mrapoc]

Ok, would probably be the easiest option. Thanks

/***********************************************************************/
/*Inclusions*/
/***********************************************************************/


#include <stdio.h>
#include <stdlib.h>
#include <string.h>




/***********************************************************************/
/*Indentifiers*/
/***********************************************************************/


unsigned char* testData(unsigned char *hex);


/***********************************************************************/
/*Main program*/
/***********************************************************************/


int main (void)
{
	/***********************************************************************/
	/*Declarations*/
	/***********************************************************************/


	int i;
	int x = 0;
	unsigned char *hex = NULL;
	hex = (unsigned char *)malloc(0x4466446);	


	/*Create test data in memory*/
	testData(hex);


	/*Display menu*/


	printf("Please make a choice: \n");


	/*Choices*/
	printf("1. Display contents of memory\n");
	printf("2. Clear location of memory\n");
	printf("3. Display location of memory\n");


	/*Choice made*/
	scanf("%d", &i);
	switch(i) {
		
		/*Display test data*/
	case 1:      
		fflush(stdin);


		for (x = 0; x <=10; x++)
		{
			printf("\nThe Value of hex %x is: %i\n",*(hex+x), *(hex+x));
			printf("\nThe value of X is: %i\n", x);
			getchar();
		}
		
		getchar();
		printf("\nPress any key to continue\n");
		break;


		/*Clear memory allocation*/
	case 2:      
		fflush(stdin);
		printf("Clearing memory...\n");
		hex = NULL;
		printf("Memory cleared!\n");
		getchar();
		printf("\nPress any key to continue\n");
		break;


		/*Show memory start and end*/
	case 3:      
		fflush(stdin);
		printf("Start of memory block: %p\n", hex);   
		printf("End of memory block: %p\n", hex + 65536 - 1);
		getchar();
		printf("\nPress any key to continue\n");
		break;


		/*Incorrect entries*/
	default:
		printf("Incorrect option");
	}
	/*Clean up*/
	printf("\nCleaning up...\n");
	free(hex);
	return 0;
}




/***********************************************************************/
/*Setup test data*/
/***********************************************************************/
unsigned char* testData(unsigned char *hex)
{


	/*Allocate memory*/
	if (hex == NULL)
	{
		printf("Cannot allocate memory \n\r");
		getchar();
		exit(1);
	}


	/*Store data*/
	*hex = 0x0F; 
	*(hex+1) = 0x11;
	*(hex+2) = 0xFF;
	*(hex+3) = 0x1B;
	*(hex+4) = 0x00;
	*(hex+5) = 0xB6;
		
	/*Return data pointer address to main*/
	return hex;


}

[Matticus]

unsigned char* testData(unsigned char *hex)

You're passing an unsigned char pointer "hex" to the function, then returning the same pointer from the function. However, the value of this pointer is not modified, so there is no sense in returning it.

Instead, consider having this function return an integer - an integer which represents the maximum offset of the "hex" pointer during initialization (i.e. in your example, this integer would end up with a value of 5). This way, you program can support variabled sized initializations of "hex".

Then simply use this return value as the criteria to exit the printing statement.

int testData(unsigned char *hex);
// ...
dataMax = testData(hex);
// ...
for (x = 0; x <=dataMax; x++)
{
    printf("\nThe Value of hex %x is: %i\n",*(hex+x), *(hex+x));
    printf("\nThe value of X is: %i\n", x);
    getchar();
}

[AndiPersti]

hex = (unsigned char *)malloc(0x4466446);

No need for casting in C

fflush(stdin);

Undefined behavior

/*Clear memory allocation*/
hex = NULL;
printf("Memory cleared!\n");

Setting a pointer to NULL isn't clearing the memory. You have to call free().

printf("Start of memory block: %p\n", hex);   
printf("End of memory block: %p\n", hex + 65536 - 1);

You have allocated 71722054 bytes of memory (0x4466446) thus hex + 65536 - 1 isn't the end of your memory block.

free(hex);

If you have "cleared the memory" before (option 2), you have lost any reference to the memory block and free() isn't able to free the block.

/*Store data*/
*hex = 0x0F; 
*(hex+1) = 0x11;
*(hex+2) = 0xFF;
*(hex+3) = 0x1B;
*(hex+4) = 0x00;
*(hex+5) = 0xB6;

You hardcode the length of your data so there is no other way to determine the end than also hardcode the length into your for-loop:

for (x = 0; x < 6; x++){

    printf("\nThe Value of hex %x is: %i\n",*(hex+x), *(hex+x));

    printf("\nThe value of X is: %i\n", x);

    getchar();

}

Bye, Andreas

[mrapoc]

Thanks for the feedback all

I'll take what you've given me and apply cheers