Declaring Static Character Arrays (strings)
When you know (or have a reasonable idea how large your array needs to be, you can simply declare an array of sufficient size to handle your input (i.e. if you names are no longer than 25 characters, then you could safely declare name[26]. For strings, you always need at minimum the number of chars to store + 1 (for the null-terminating character).
If there may be a few characters more than 25, there's nothing wrong with declaring your array few bytes longer than needed to protect against accidental writing beyond the end of the array. Say name[32].
Let's declare an array of 5-characters below and look at how the information is stored in memory.
char name[5] = {0}; /* always initialize your arrays */
The above declaration creates an array of 5-contiguous bytes on the stack for your use. e.g., you can visualize the 5-bytes of memory initialized to zero as follows:
+---+---+---+---+---+
name | 0 | 0 | 0 | 0 | 0 |
+---+---+---+---+---+
\
'name' holds the starting address for
the block of memory that is the array
(i.e. the address of the first element
like: 0x7fff050bf3d0)
Note: when using name to hold a 'character string', the actual string can be no longer than 4 chars because you must end a sting with a null-terminating character, which is the null-character '\0' (or simply numeric 0, both are equivalent)
To store information in name, you can either do it by assigning characters one-at-a-time:
name[0] = 'J';
name[1] = 'o';
name[2] = 'h';
name[3] = 'n';
name[4] = 0; /* null-terminate. note: this was already done by initialization */
In memory you now have:
+---+---+---+---+---+
name | J | o | h | n | 0 | /* you actually have the ASCII value for */
+---+---+---+---+---+ /* each letter stored in the elements */
Of course, nobody assigns one character at a time in this manner. You options are many, using one of the functions provided by C, e.g. strcpy, strncpy, memcpy, or by reading information from a file stream, or file descriptor with fgets, getline, or by using a simple loop and index variable to do the assignment, or by using one of the string formatting functions, e.g. sprintf, etc... For example you can accomplish the same thing with any of the following:
/* direct copy */
strcpy (name, "John");
strncpy (name, "John", 5);
memcpy (name, "John", sizeof "John"); /* include copy of the terminating char */
/* read from stdin into name */
printf ("Please enter a name (4 char max): ");
scanf ("%[^\n]%*c", name);
Note: above with strncpy, if you had NOT initialized all element to 0 (the last of which will serve as your null-terminating character, and then used strncpy (name, "John", 4); you would need to manually terminate the string with name[4] = 0;, otherwise you would not have a valid string (you would have an unterminated array of chars which would lead to undefined behavior if you used name where a string was expected.)
If you do not explicitly understand this STOP, go read and understand what a null-terminated string is and how it differs from an array of characters. Seriously, stop now and go learn, it is that fundamental to C. (if it doesn't end with a null-terminating character - it isn't a c-string.
What if I don't know how many characters I need to store?
Dynamic Allocations of Character Strings
When you do not know how many characters you need to store (or generally how many of whatever data type), the normal approach is to declare a pointer to type, and then allocate a reasonably anticipated amount of memory (just based on your best understanding of what you are dealing with), and then reallocate to add additional memory as required. There is no magic to it, it is just a different way of telling the compiler how to manage the memory. Just remember, when you allocate the memory, you own it. You are responsible for (1) preserving a pointer to the beginning address of the memory block (so it can be freed later); and (2) freeing the memory when you are done with it.
A simple example will help. Most of the memory allocation/free functions are declared in stdlib.h.
char *name = NULL; /* declare a pointer, and initialize to NULL */
name = malloc (5 * sizeof *name); /* allocate a 5-byte block of memory for name */
if (!name) { /* validate memory was allocated -- every time */
fputs ("error: name allocation failed, exiting.", stderr);
exit (EXIT_FAILURE);
}
/* Now use name, just as you would the statically declared name above */
strncpy (name, "John", 5);
printf (" name contains: %s\n", name);
free (name); /* free memory when no longer needed.
(if reusing name, set 'name = NULL;')
*/
Note: malloc does NOT initialize the contents of the memory it allocates. If you want to initialize your new block of memory with zero (as we did with the static array), then use calloc instead of malloc. You can also use malloc and then call memset as well.
What happens if I allocate memory, then need More?
As mentioned above discussing dynamic memory, the general scheme is to allocate a reasonable anticipated amount, then realloc as required. You use realloc to reallocate the original block of memory created by malloc. realloc essentially creates a new block of memory, copies the memory from your old block to the new, and then frees the old block of memory. Since the old block of memory is freed, you want to use a temporary pointer for reallocation. If reallocation fails, you still have your original block of memory available to you.
You are free to add as little or as much memory as you like at any call to realloc. The standard scheme usually seen is to start with some initial allocation, then reallocate twice that amount each time you run out. (the means you need to keep track of how much memory is currently allocated).
To sew this up, let's end with a simple example that simply reads a string of any length as the first argument to the program (use "quotes" if your string contains whitespace). It will then allocates space to hold the string, then reallocate to append more text to the end of the original string. Finally it will free all memory in use before exit:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main (int argc, char **argv) {
if (argc < 2) { /* validate input */
fprintf (stderr, "error: insufficient input. usage: %s \"name\"\n",
argv[0]);
return 1;
}
size_t len = strlen (argv[1]); /* length of input */
size_t sz_mem = len + 1; /* memory required */
char *name = malloc (sz_mem * sizeof *name); /* allocate memory for name */
if (!name) { /* validate memory created successfully or throw error */
fputs ("error: name allocation failed, exiting.", stderr);
return 1;
}
printf ("\n allocated %zu bytes of memory for 'name'\n", sz_mem);
memset (name, 0, sz_mem); /* initialize memory to zero (optional) */
strncpy (name, argv[1], sz_mem); /* copy the null-terminator as well */
printf (" name: '%s' (begins at address: %p)\n", name, name);
/* realloc - make name twice as big */
void *tmp = realloc (name, 2 * sz_mem); /* use a temporary pointer */
if (!tmp) { /* check realloc succeeded */
fprintf (stderr, "error: virtual memory exhausted, realloc 'name'\n");
return 1;
}
memset (tmp + sz_mem, 0, sz_mem * sizeof *name); /* zero new memory */
name = tmp; /* assign new block to name */
sz_mem += sz_mem; /* update current allocation size */
printf (" reallocated 'name' to %zu bytes\n", sz_mem);
strncat (name, " reallocated", sizeof " reallocated");
printf ("\n final name : '%s'\n\n", name);
free (name);
return 0;
}
Use/Output
$ ./bin/arraybasics "John Q. Public"
allocated 15 bytes of memory for 'name'
name: 'John Q. Public' (begins at address: 0xf17010)
reallocated 'name' to 30 bytes
final name : 'John Q. Public reallocated'
Memory Check
When you dynamically allocate memory, it is up to you to validate you are using the memory correctly and that you track and free all the memory you allocate. Use a memory error checker like valgrind to veryify your memory use is correct. (there is no excuse not to, it is dead-bang-simple to do) Just type valgrind yourprogramexe
$ valgrind ./bin/arraybasics "John Q. Public"
==19613== Memcheck, a memory error detector
==19613== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==19613== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==19613== Command: ./bin/arraybasics John\ Q.\ Public
==19613==
allocated 15 bytes of memory for 'name'
name: 'John Q. Public' (begins at address: 0x51e0040)
reallocated 'name' to 30 bytes
final name : 'John Q. Public reallocated'
==19613==
==19613== HEAP SUMMARY:
==19613== in use at exit: 0 bytes in 0 blocks
==19613== total heap usage: 2 allocs, 2 frees, 45 bytes allocated
==19613==
==19613== All heap blocks were freed -- no leaks are possible
==19613==
==19613== For counts of detected and suppressed errors, rerun with: -v
==19613== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)
In the output, the following lines are of particular significance:
==19613== HEAP SUMMARY:
==19613== in use at exit: 0 bytes in 0 blocks
==19613== total heap usage: 2 allocs, 2 frees, 45 bytes allocated
This tells you that all memory allocated during your program has been properly freed. (make sure you close all open file streams, they are dynamically allocated as well).
Of equal importance is the ERROR SUMMARY:
==19613== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)
There are no errors in the memory use. If you attempt to read, write or free memory from a location outside your block, or from an unitialized location or that would leave other memory unreachable, that information will show as an error.
(the suppressed: 2 from 2 just relate to additional debug libraries not present on my system)
This ended up longer than intended, but if it helps, it was worth it. Good luck.
Answer from David C. Rankin on Stack OverflowDeclaring Static Character Arrays (strings)
When you know (or have a reasonable idea how large your array needs to be, you can simply declare an array of sufficient size to handle your input (i.e. if you names are no longer than 25 characters, then you could safely declare name[26]. For strings, you always need at minimum the number of chars to store + 1 (for the null-terminating character).
If there may be a few characters more than 25, there's nothing wrong with declaring your array few bytes longer than needed to protect against accidental writing beyond the end of the array. Say name[32].
Let's declare an array of 5-characters below and look at how the information is stored in memory.
char name[5] = {0}; /* always initialize your arrays */
The above declaration creates an array of 5-contiguous bytes on the stack for your use. e.g., you can visualize the 5-bytes of memory initialized to zero as follows:
+---+---+---+---+---+
name | 0 | 0 | 0 | 0 | 0 |
+---+---+---+---+---+
\
'name' holds the starting address for
the block of memory that is the array
(i.e. the address of the first element
like: 0x7fff050bf3d0)
Note: when using name to hold a 'character string', the actual string can be no longer than 4 chars because you must end a sting with a null-terminating character, which is the null-character '\0' (or simply numeric 0, both are equivalent)
To store information in name, you can either do it by assigning characters one-at-a-time:
name[0] = 'J';
name[1] = 'o';
name[2] = 'h';
name[3] = 'n';
name[4] = 0; /* null-terminate. note: this was already done by initialization */
In memory you now have:
+---+---+---+---+---+
name | J | o | h | n | 0 | /* you actually have the ASCII value for */
+---+---+---+---+---+ /* each letter stored in the elements */
Of course, nobody assigns one character at a time in this manner. You options are many, using one of the functions provided by C, e.g. strcpy, strncpy, memcpy, or by reading information from a file stream, or file descriptor with fgets, getline, or by using a simple loop and index variable to do the assignment, or by using one of the string formatting functions, e.g. sprintf, etc... For example you can accomplish the same thing with any of the following:
/* direct copy */
strcpy (name, "John");
strncpy (name, "John", 5);
memcpy (name, "John", sizeof "John"); /* include copy of the terminating char */
/* read from stdin into name */
printf ("Please enter a name (4 char max): ");
scanf ("%[^\n]%*c", name);
Note: above with strncpy, if you had NOT initialized all element to 0 (the last of which will serve as your null-terminating character, and then used strncpy (name, "John", 4); you would need to manually terminate the string with name[4] = 0;, otherwise you would not have a valid string (you would have an unterminated array of chars which would lead to undefined behavior if you used name where a string was expected.)
If you do not explicitly understand this STOP, go read and understand what a null-terminated string is and how it differs from an array of characters. Seriously, stop now and go learn, it is that fundamental to C. (if it doesn't end with a null-terminating character - it isn't a c-string.
What if I don't know how many characters I need to store?
Dynamic Allocations of Character Strings
When you do not know how many characters you need to store (or generally how many of whatever data type), the normal approach is to declare a pointer to type, and then allocate a reasonably anticipated amount of memory (just based on your best understanding of what you are dealing with), and then reallocate to add additional memory as required. There is no magic to it, it is just a different way of telling the compiler how to manage the memory. Just remember, when you allocate the memory, you own it. You are responsible for (1) preserving a pointer to the beginning address of the memory block (so it can be freed later); and (2) freeing the memory when you are done with it.
A simple example will help. Most of the memory allocation/free functions are declared in stdlib.h.
char *name = NULL; /* declare a pointer, and initialize to NULL */
name = malloc (5 * sizeof *name); /* allocate a 5-byte block of memory for name */
if (!name) { /* validate memory was allocated -- every time */
fputs ("error: name allocation failed, exiting.", stderr);
exit (EXIT_FAILURE);
}
/* Now use name, just as you would the statically declared name above */
strncpy (name, "John", 5);
printf (" name contains: %s\n", name);
free (name); /* free memory when no longer needed.
(if reusing name, set 'name = NULL;')
*/
Note: malloc does NOT initialize the contents of the memory it allocates. If you want to initialize your new block of memory with zero (as we did with the static array), then use calloc instead of malloc. You can also use malloc and then call memset as well.
What happens if I allocate memory, then need More?
As mentioned above discussing dynamic memory, the general scheme is to allocate a reasonable anticipated amount, then realloc as required. You use realloc to reallocate the original block of memory created by malloc. realloc essentially creates a new block of memory, copies the memory from your old block to the new, and then frees the old block of memory. Since the old block of memory is freed, you want to use a temporary pointer for reallocation. If reallocation fails, you still have your original block of memory available to you.
You are free to add as little or as much memory as you like at any call to realloc. The standard scheme usually seen is to start with some initial allocation, then reallocate twice that amount each time you run out. (the means you need to keep track of how much memory is currently allocated).
To sew this up, let's end with a simple example that simply reads a string of any length as the first argument to the program (use "quotes" if your string contains whitespace). It will then allocates space to hold the string, then reallocate to append more text to the end of the original string. Finally it will free all memory in use before exit:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main (int argc, char **argv) {
if (argc < 2) { /* validate input */
fprintf (stderr, "error: insufficient input. usage: %s \"name\"\n",
argv[0]);
return 1;
}
size_t len = strlen (argv[1]); /* length of input */
size_t sz_mem = len + 1; /* memory required */
char *name = malloc (sz_mem * sizeof *name); /* allocate memory for name */
if (!name) { /* validate memory created successfully or throw error */
fputs ("error: name allocation failed, exiting.", stderr);
return 1;
}
printf ("\n allocated %zu bytes of memory for 'name'\n", sz_mem);
memset (name, 0, sz_mem); /* initialize memory to zero (optional) */
strncpy (name, argv[1], sz_mem); /* copy the null-terminator as well */
printf (" name: '%s' (begins at address: %p)\n", name, name);
/* realloc - make name twice as big */
void *tmp = realloc (name, 2 * sz_mem); /* use a temporary pointer */
if (!tmp) { /* check realloc succeeded */
fprintf (stderr, "error: virtual memory exhausted, realloc 'name'\n");
return 1;
}
memset (tmp + sz_mem, 0, sz_mem * sizeof *name); /* zero new memory */
name = tmp; /* assign new block to name */
sz_mem += sz_mem; /* update current allocation size */
printf (" reallocated 'name' to %zu bytes\n", sz_mem);
strncat (name, " reallocated", sizeof " reallocated");
printf ("\n final name : '%s'\n\n", name);
free (name);
return 0;
}
Use/Output
$ ./bin/arraybasics "John Q. Public"
allocated 15 bytes of memory for 'name'
name: 'John Q. Public' (begins at address: 0xf17010)
reallocated 'name' to 30 bytes
final name : 'John Q. Public reallocated'
Memory Check
When you dynamically allocate memory, it is up to you to validate you are using the memory correctly and that you track and free all the memory you allocate. Use a memory error checker like valgrind to veryify your memory use is correct. (there is no excuse not to, it is dead-bang-simple to do) Just type valgrind yourprogramexe
$ valgrind ./bin/arraybasics "John Q. Public"
==19613== Memcheck, a memory error detector
==19613== Copyright (C) 2002-2012, and GNU GPL'd, by Julian Seward et al.
==19613== Using Valgrind-3.8.1 and LibVEX; rerun with -h for copyright info
==19613== Command: ./bin/arraybasics John\ Q.\ Public
==19613==
allocated 15 bytes of memory for 'name'
name: 'John Q. Public' (begins at address: 0x51e0040)
reallocated 'name' to 30 bytes
final name : 'John Q. Public reallocated'
==19613==
==19613== HEAP SUMMARY:
==19613== in use at exit: 0 bytes in 0 blocks
==19613== total heap usage: 2 allocs, 2 frees, 45 bytes allocated
==19613==
==19613== All heap blocks were freed -- no leaks are possible
==19613==
==19613== For counts of detected and suppressed errors, rerun with: -v
==19613== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)
In the output, the following lines are of particular significance:
==19613== HEAP SUMMARY:
==19613== in use at exit: 0 bytes in 0 blocks
==19613== total heap usage: 2 allocs, 2 frees, 45 bytes allocated
This tells you that all memory allocated during your program has been properly freed. (make sure you close all open file streams, they are dynamically allocated as well).
Of equal importance is the ERROR SUMMARY:
==19613== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)
There are no errors in the memory use. If you attempt to read, write or free memory from a location outside your block, or from an unitialized location or that would leave other memory unreachable, that information will show as an error.
(the suppressed: 2 from 2 just relate to additional debug libraries not present on my system)
This ended up longer than intended, but if it helps, it was worth it. Good luck.
How can I announce the array and then define it's size?
Don't; 'announce' it when you know what size it needs to be. You can't use it before then anyway.
In C99 and later, you can define variables when needed — anywhere in a statement block. You can also use VLAs (variable-length arrays) where the size is not known until runtime. Don't create enormous arrays as VLAs (e.g. 1 MiB or more — but tune the limit to suit your machine and prejudices); use dynamic memory allocation after all.
If you're stuck with the archaic C89/C90 standard, then you can only define variables at the start of a block, and arrays have sizes known at compile time, so you have to use dynamic memory allocation — malloc(), free() etc.
Hey friends,
I'm sure somebody on the internet jas alread answered this, but I honestly haven't found a suitable answer for me.
Let's say we have a struct like this:
typedef struct {
char *name;
int age;
} Human;And a kind of "constructor" function like this:
Human *human_new(char *name, int age)
{
Human *this = (Human *) malloc(sizeof(Human));
this->name = name;
this->age = age;
return this;
}
My question is, do I need to allocate memory for the char pointer name of the struct or is the assignment of this->name enough?
c - Allocating char array using malloc - Stack Overflow
sizeof Char / Array length Memory allocation in C, - Stack Overflow
Memory Allocation of char** array in C - Stack Overflow
arrays - C memory allocations - Stack Overflow
Videos
Yes, it's a matter of style, because you'd expect sizeof(char) to always be one.
On the other hand, it's very much an idiom to use sizeof(foo) when doing a malloc, and most importantly it makes the code self documenting.
Also better for maintenance, perhaps. If you were switching from char to wchar, you'd switch to
Copywchar *p = malloc( sizeof(wchar) * ( len + 1 ) );
without much thought. Whereas converting the statement char *p = malloc( len + 1 ); would require more thought. It's all about reducing mental overhead.
And as @Nyan suggests in a comment, you could also do
Copytype *p = malloc( sizeof(*p) * ( len + 1 ) );
for zero-terminated strings and
Copytype *p = malloc( sizeof(*p) * len ) );
for ordinary buffers.
It serves to self-document the operation. The language defines a char to be exactly one byte. It doesn't specify how many bits are in that byte as some machines have 8, 12, 16, 19, or 30 bit minimum addressable units (or more). But a char is always one byte.
You are not printing addresses correctly: an address is not an int, so you cannot use %d to print it. Use %p (for "pointer") instead, and cast the address to void* for printing:
printf ("This is the Address of val1 %p\n", (void*)&foo[1]);
Now your program produces this or similar output:
This is the Address of val1 0xffbd2fcf
This is the Address of val2 0xffbd2fd0
The size of each array member is 2
Two pointers are off by 1, which is the size of a single char. The size of the entire array is 2. If you want to print the size of a single element, use foo[0].
Memory Allocation is a bit tricky, but it's easier than you think. It is, as the name implies, the usage and selection of data to optimize program function and speed. Basically, Memory Allocation is a "perk" of languages such as C/C++ that allow programmers to only use EXACTLY as much data as needed, freeing up memory for other computer functions.
Some good info to know about memory...
- memory is known in "bytes", these are 8-bit "groups" of data.
- A "bit" is a value that is either 0 or 1.
Variable sizes:
- Char: 1 byte
- Int: 4 bytes
- double: 8 bytes
When neighboring elements are of the same type (for example, an array of chars), they will have a difference in address that increments/decrements by the value of the memory size. Since a char variable has a size of 1 byte, neighboring elements will have addresses that differ by 1.
Ex: char addresses: 1204, 1205, 1206, 1207... (1 byte)
int addresses: 1204, 1208, 1212, 1216... (4 bytes)
This code:
#include <stdio.h>
int main(void)
{
char example[] = "An example string";
printf("%zu", sizeof(example));
}
Compiled with:
gcc -std=c99 -o proof proof.c
Returns:
18 (bytes, not bits)
Because of the \0 character at the end of string
The size of a null (\0) terminated string of strlen n is n+1. As you say, one extra for the null character.
If string litterals weren't terminated, standard calls like strlen could not work as they look for the terminating \0.
Almost. Strings are NUL terminated, so you probably want to allocate an extra byte to store the NUL byte. That is, even though sides is 1 character long, it really is 2 bytes: {5,'\0'}.
So it would be:
tempSides = (char *)malloc((strlen(sides)+1)*sizeof(char));
and if you wanna copy it in:
strcpy(tempSides, sides);
Note that:
- Strings are zero-terminated (\0), and strlen() doesn't count it;
- By definition, sizeof(char) is 1 (byte), so it's not required;
- If you use a C (not C++) compiler, there's no need to cast it to
char *;
So that would be:
char *tempSides = malloc(strlen(inSides) + 1);
Still, if you want to duplicate the contents of inSides, you can use strdup, e.g.:
char *tempSides = strdup(inSides);
if (tempSides != NULL) {
// do whatever you want...
free(tempSides);
}
memcpy does not allocate any memory. In your memcpy call, the memory for the destination arr was allocated when the variable arr was defined (char arr[400]).
There's a problem there, which is that you haven't allocated enough room. You copy sizeof(updata) bytes into arr, which is probably 1+4+7*256=1797 (this may vary depending on sizeof(int) and on whether __packed__ actually leaves out all unused bytes on your platform). If you really need arr (you probably don't), make it at least sizeof(updata) large. Defining it with char arr[sizeof(updata)] is fine.
If the layout of the structure is defined by some external format, you should use a fixed-size type instead of int (which is 2 or 4 bytes depending on the platform, and could be other sizes but you're unlikely to encounter them).
If the layout of the structure is defined by some external binary format and you want to print out the 1797 bytes in this format, use fwrite.
fwrite(updata, sizeof(updata), 1, stdout);
If you want to have a human representation of the data, use printf with appropriate format specifications.
printf("ip='%c' udp=%d\n", updata.ip, updata.ip);
for (i = 0; i < sizeof(updata.rules)/sizeof(updata.rules[0]); i++) {
puts(updata.rules[i].myname);
}
Despite the name, char is in fact the type of bytes. There is no separate type for characters in C. A character constant like 'a' is in fact an integer value (97 on almost all systems, as per ASCII). It's things like writing it with putchar or printf("%c", …) that make the byte interpreted as a character.
If your compiler is not signaling an error when you mix up a pointer (such as char*) with an integer, on the other hand, turn up the warning level. With Gcc, use at least gcc -O -Wall.
After actually compiling your code, I see the main error (you should have copy-pasted the error message from the compiler in your question):
udpdata.rules[0].myname = "lalla\0" ;
udpdata.rules[0].myname is an array of bytes. You can't assign to an array in C. You need to copy the elements one by one. Since this is an array of char, and you want to copy a string into it, you can use strcpy to copy all the bytes of the string. For a bunch of bytes in general, you would use memcpy.
strcpy(udpdata.rules[0].myname, "lalla");
(Note that "lalla\0" is equivalent to "lalla", all string literals are zero-terminated in C.¹) Since strcpy does not perform any size verification, you must make sure that the string (including its final null character) fits in the memory that you've allocated for the targets. You can use other functions such as strncat or strlcpy if you want to specify a maximum size.
¹ There's one exception (and only this exception) where "lalla" won't be zero-terminated: when initializing an array of 5 bytes, e.g. char bytes[5] = "lalla". If the array size is at least 6 or unspecified, there will be a terminating zero byte.
// this is really bad udpdata.rules[0].myname = "lalla\0" ; // do this instead. You want the literal string in your field. memcpy(udpdata.rules[0].myname, "lalla\0", 6); .... // This is wrong. arr is already a pointer. memcpy (&arr , &udpdata, sizeof(udpdata)); // do this instead mempcy (arr, &udpdata, sizeof(udpdate));
Concerning printing, I don't know how big ints are on your machine but if they are 4 bytes then
printf("%.7s", &arr[1+4]);
I'm not sure why you want to convert everything to a char array if you wanted to print out the content. Just use the struct and a for loop. Anyway I think you may want to read up on C arrays.
So this is one of those questions where I have a bug and I think I kind of know what's going on, and my hypothesis has led me to ask the question, but I could be wrong and the question could have nothing to do with the actual problem.
I'm working on writing tests for a complex project for which I'm part of a team. I have some mocked functions for testing, and there's a whole framework for these mocked functions, and I can set the returns from these mocked functions using this framework. What happens often is that other test cases were not set up/closed down properly, and the mocked returns will "pollute" other tests. This seems to likely be the root of my issue.
In trying to debug this, I have a variable `foo`, which I want to be returned from a mocked function. I'm using the debugger to step through and see if `foo` is indeed being returned where I expect it to be. To compare the address of what's actually being returned to what I'm setting as the return, I throw a `SOME_TYPE* fooAddr = &foo;` in my test case code.
Now for some reason, when doing this, my issue vanishes. So my only guess is that there is some out of bounds memory access going on, and by making a new variable `fooAddr` here, it essentially puts some "padding" somewhere in memory which causes that memory out of bounds error to not actually fuck up stuff that shouldn't be fucked up; it might very well be fucking up `fooAddr`, but that doesn't affect anything in the tests.
So I mess around with this further to verify if this is the case. If I do, for example, this `SOME_TYPE*` variable, no issue. If I do a void*, no issue. If I do a char*, no issue. If I do a char[100], the issue appears. if I do a few `char`s, the issue shows up. If I do MORE chars, the issue disappears.
It seems the supposed OOB memory error needs a certain amount of "padding" to not blow up, and if I don't give it enough, the issue will persist.
My question is: why does something like a char* work, but a char[100] doesn't? I'm wondering if it has something to do with how memory for these things is allocated? Like a char* will be allocated "right there" in memory, which apparently helps my issue not be an issue. Yet a larger array of characters is "over there" and therefore doesn't help my issue.
This is all me spitballing and trying to figure it out on my own, so I may be way off basis with the overarching question, and I'd love to hear insights onto this
If i have an array already full of data in a function:
char line [10] [128]
how would i dynamically allocate it so that i can use it in other functions?