Have you ever heard a programmer mock the C language? Recently, a C# programmer informed me that C was okay, but “you can’t even split a string in C in less than 20 lines of code.”<\/p>\n
Challenge accepted!
\n
\nThe C# language has several fun and interesting string methods, which are like functions for object-oriented languages. You can parse strings, replace text within a string, and a whole host of fun and useful tasks. But C was specifically mocked regarding its inability to split a string by using a tidy number of statements.<\/p>\n
I’m not going to bother to research how C# splits a string. Instead, I concocted a function with four arguments:<\/p>\n
original<\/em> is the original string, the one to be split in two.<\/p>\n offset<\/em> is the character position at which the string is to be split, with offset<\/em> characters sent to the first string and the remaining characters sent to the second.<\/p>\n s1<\/em> and s2<\/em> are pointer-pointers representing the strings to contain the split. They’re declared in the calling function as pointer variables with their addresses are passed to the function, which is why I use the The split()<\/em> function returns 1 upon success, 0 otherwise.<\/p>\n The good news is that the function, which I wrote in my standard way of formatting the C language (no collapsed statements or anything tricky) is only 15 lines long.<\/p>\n The first thing the split()<\/em> function does is to obtain the length of the original string:<\/p>\n If the split ( Second, storage is allocated for the two string buffers. These variables are passed as addresses because you cannot modify a pointer variable argument directly within a function; you must pass the address of the pointer variable instead. (Check Line 27 in the main()<\/em> function.)<\/p>\n Storage is allocated for the size of each new string, Finally, given the size of the original string and the split, two strncpy()<\/em> functions copy portions of the original string into the two, freshly-allocated string buffers:<\/p>\n The first strncpy()<\/em> function copies characters into the first string, Here’s a sample run:<\/p>\n If you can concoct a solution shorter than 15 lines, and without cramming all the statements on a single line, I’d enjoy seeing it. I’d love to show Mr. Smartypants C# Programmer that C is more than up to the task of splitting a string in fewer than 20 lines.<\/p>\n","protected":false},"excerpt":{"rendered":" Yes, those hauteur programming languages have some simple tricks, but nothing that C is incapable of doing. Continue reading int split(char *original, int offset, char **s1, char **s2)<\/code><\/p>\n**<\/code> notation. More on this process in a few paragraphs.<\/p>\n\r\n#include <stdio.h>\r\n#include <stdlib.h>\r\n#include <string.h>\r\n\r\nint split(char *original,int offset,char **s1,char **s2)\r\n{\r\n int len;\r\n\r\n len = strlen(original);\r\n if(offset > len)\r\n return(0);\r\n *s1 = (char *)malloc(sizeof(char) * offset+1);\r\n *s2 = (char *)malloc(sizeof(char) * len-offset+1);\r\n if( s1==NULL || s2==NULL )\r\n return(0);\r\n strncpy(*s1,original,offset);\r\n strncpy(*s2,original+offset,len-offset);\r\n return(1);\r\n}\r\n\r\nint main()\r\n{\r\n char string[] = \"We shall attempt to split this string\";\r\n char *first,*second;\r\n int r;\r\n\r\n r = split(string,16,&first,&second);\r\n if(r==1)\r\n {\r\n printf(\"Split successful\\n\");\r\n printf(\"'%s' split into:\\n\",string);\r\n printf(\"'%s'\\n\",first);\r\n printf(\"'%s'\\n\",second);\r\n }\r\n else\r\n {\r\n puts(\"The function was unable to split the string\");\r\n }\r\n\r\n return(0);\r\n}<\/pre>\nlen = strlen(original);
\nif(offset > len)
\n return(0);<\/code><\/p>\noffset<\/code>) is greater than the string’s length, the function returns 0, failure. (The function can “split” a string the same length as the original string, in which case you end up with a copy of the original string and an empty string.)<\/p>\n*s1 = (char *)malloc(sizeof(char) * offset+1);
\n*s2 = (char *)malloc(sizeof(char) * len-offset+1);
\nif( s1==NULL || s2==NULL )
\n return(0);<\/code><\/p>\n+1<\/code> for the null character, \\0<\/code>. If either allocation fails, the function returns with 0, failure.<\/p>\nstrncpy(*s1,original,offset);
\nstrncpy(*s2,original+offset,len-offset);<\/code><\/p>\ns1<\/code>, up to and including the split at offset<\/code>. The second strncpy()<\/em> function starts at offset<\/code> and copies the rest of the characters into string s2<\/code>.<\/p>\nSplit successful\r\n'We shall attempt to split this string' split into:\r\n'We shall attempt'\r\n' to split this string'<\/code><\/pre>\n