{"id":133,"date":"2014-12-20T01:19:12","date_gmt":"2014-12-20T01:19:12","guid":{"rendered":"http:\/\/www.troliver.com\/?p=133"},"modified":"2015-01-06T15:24:53","modified_gmt":"2015-01-06T15:24:53","slug":"using-characters-malloc-memcpy-and-compiling-in-c-in-visual-studio-aka-weird-stuff-that-can-happen-when-adding-strings","status":"publish","type":"post","link":"https:\/\/www.troliver.com\/?p=133","title":{"rendered":"Using characters, malloc, memcpy and compiling in C in Visual Studio (aka weird stuff that can happen when adding strings)"},"content":{"rendered":"

(I am trying out a new theme today called Crayon syntax highlighter <\/a>which should hopefully make some of these coding examples I do look a bit prettier. I set it to the Visual Studio 2012 theme, which means using Consolas as the font. So lets see how this goes!)<\/em><\/p>\n

Today I will show you what happens when you do something totally logical but, actually, not in the correct way (and arguably not even a way in which you should do it at all<\/a>, but we will have to ignore that for now). First of all, some background; in an attempt to add together some strings of an undetermined length, I created a function which did some very bizarre things. I will go through some background of using characters and lead onto what happened. So as a really basic example, we can just make a new\u00a0C++ console project in Visual Studio and do the following in a main .cpp;<\/p>\n

Characters<\/strong><\/h2>\n
#include \"stdafx.h\"\r\nint _tmain(int argc, _TCHAR* argv[])\r\n{\r\n\tfirstname = \"Arseniy \";\r\n\tsurname = \"Yatsenyuk\";\r\n\r\n\taddstrings(&name, firstname, surname);\r\n\treturn 0;\r\n}\r\n<\/pre>\n
We basically have two strings of text that represent a first name and a surname (I was going to choose Putin but I decided that Yatsenyuk is a good guy at this point in time and I feel quite positive writing this).<\/p>\n
Important note here: a string is an array of ascii characters. Each character is one byte and can be anywhere from 0 to 255 in value. Actually, it is an array of characters, terminated with a null termination character. This means we just fill up a character, or an array of characters, with numbers that correspond to text (or escape characters, such as the termination character).<\/p>\n
Oh yeah, we need to add three strings too, so if we declare them outside of the main function, we can use them everywhere in our program;<\/p>\n
char * name;\r\nchar * firstname;\r\nchar * surname;\r\n<\/pre>\n
So what we do here is to declare three character pointers. Which can represent a string.\u00a0What does this do? It allocates a\u00a0pointer to a memory location<\/em>\u00a0that will represent a character (which is a single byte of data). Why is this important? Because this post relies on using memory addresses quite a lot and understanding how pointers work is really important in this basic example. Or rather, this basic example should be able to demonstrate using pointers a bit more.<\/p>\n
If we then look back at what we are doing by giving a value to “firstname”, we are actually not giving it a single value (which would be written using a single-quote, for example ‘a’ or ‘H’) but a string of values<\/strong>.<\/p>\n
What this statement does is to create a new array of characters, of the correct length (plus one, actually, as it will add a null-termination character onto the end of the array – which is a ‘\\0’. The length, therefore, is going to be one character more than you would think it should be!). It does this by assigning some new memory to an array of characters and, because the variable “firstname” is a pointer, what we actually<\/em>\u00a0get back is just that – a pointer to the memory location where this new array of characters is stored. So “firstname” does not store any text; it stores the memory address of where the character array actually resides in memory.<\/p>\n
So (firstname = “Arseniy “) is an initialisation function, returning the address of “A” as its result. To access any letter, we can just say “firstname[3]” to access the “e” – or we can say “firstname + 3”.<\/p>\n
Now hold up a minute, you may rightly say. Adding to an array, what?! Well that would be wrong entirely; you are not adding to an array, because “firstname” is not an array. It is a pointer to a location in memory.\u00a0<\/em>So what you actually are doing, is referring to a place in memory\u00a0that is three values higher than “firstname”. Which is exactly what “firstname[3]” refers to, as well. But if we use this memory address, we will receive the value stored there; which is “e”.<\/p>\n
Alternatively we could initialise both of these as arrays in the first place.<\/p>\n
char firstname[] = \"Arseniy \"\r\nchar surname[16] = \"Yatsenyuk\"<\/pre>\n
These are analogous to doing the following:<\/p>\n
char firstname[9] = {'A', 'r', 's', 'e', 'n', 'i', 'y', ' ', '\\0'};\r\nchar surname[16] = {'Y', 'a', 't', 's', 'e', 'n', 'y', ' u ', 'k', 0, 0, 0, 0, 0, 0, 0 };<\/pre>\n
There is a difference here, which is that when we specify an array size ourselves, assigning the string to it will not terminate it (and the rest of the values are 0s). However, if we give the array no size, it will be sized as the length of the string we give it plus one (for the termination character). Sometimes we might not want the termination character – indeed, when you are combining strings, you might not want to include this character too!<\/p>\n
However, we don’t know necessarily what we are going to do with the character arrays; especially in the case of “name”, which will combine the two. We won’t know until runtime how big this will be so we have to use pointers in order to allocate memory on the heap<\/i>. This is memory for dynamically allocated resources and, because we have no idea what memory we will necessarily be given at runtime (and it changes depending on system availability), we need to use pointers to store the memory as it is allocated.<\/p>\n
(It is worth noting that passing arrays of characters as parameters in functions will pass them\u00a0by reference<\/em> by default. This is important to note, because any changes you make within that function will affect the original data being passed in; so to prevent against this, we will specify the signature as being const char * rather than simply char*. What actually will get passed is not the array but the pointer<\/em> to the first address of the array – even if an array size is specified in the function signature, it is just ignored)<\/p>\n
The function<\/h2>\n
Ok so now we have our character pointers made, let’s look at that actual “addstrings” function. Warning: anyone who really really knows C or C++ will hate how I have written this.<\/p>\n
void addstrings(char ** result, char * firstpart, char * secondpart)\r\n{\r\n\tint x = strlen(firstpart);\r\n\tint y = strlen(secondpart);\r\n\r\n\t*result = (char *)malloc((x + y + 1) * sizeof(char));\r\n\r\n\tmemcpy(*result,\t\t\tfirstpart,\t\tx);\r\n\tmemcpy(*result + x,\t\tsecondpart,\t\ty);\r\n\r\n\t*result[x + y] = '\\0';\r\n}\r\n<\/pre>\n
What we do here is:<\/p>\n