c-strings

I tried using strncmp but it only works if I give it a specific number of bytes I want to extract. char line[256] = This "is" an example. //I want to extract "is" char line[256] = This is "also" an example. // I want to extract "also" char line[256] = This is the final "example". // I want to extract "example" char substring[256] How would I extract all the elements in between the ""? and put it in the variable substring? Floris Note: I edited this answer after I realized that as written the code would cause a problem as strtok doesn't like to operate on const char* variables. This was more an

what should I use when I want to copy src_str to dst_arr and why? char dst_arr[10]; char *src_str = "hello"; PS: my head is spinning faster than the disk of my computer after reading a lot of things on how good or bad is strncpy and strlcpy . Note: I know strlcpy is not available everywhere. That is not the concern here. strncpy is never the right answer when your destination string is zero-terminated. strncpy is a function intended to be used with non-terminated fixed-width strings. More precisely, its purpose is to convert a zero-terminated string to a non-terminated fixed-width string (by

No guides I've seen seem to explain this very well. I mean, you can allocate memory for a char* , or write char[25] instead? What's the difference? And then there are literals, which can't be manipulated? What if you want to assign a fixed string to a variable? Like, stringVariable = "thisIsALiteral" , then how do you manipulate it afterwards? Can someone set the record straight here? And in the last case, with the literal, how do you take care of null-termination? I find this very confusing. EDIT: The real problem seems to be that as I understand it, you have to juggle these different

Consider the code: struct Foo { const char str[] = "test"; }; int main() { Foo foo; } It fails to compile with both g++ and clang++, spitting out essentially error: array bound cannot be deduced from an in-class initializer I understand that this is what the standard probably says, but is there any particular good reason why? Since we have a string literal it seems that the compiler should be able to deduce the size without any problem, similarly to the case when you simply declare an out-of-class const C-like null terminated string. sbabbi The reason is that you always have the possibility to

For regular C strings, a null character '\0' signifies the end of data. What about std::string , can I have a string with embedded null characters? Yes you can have embedded nulls in your std::string . Example: std::string s; s.push_back('\0'); s.push_back('a'); assert(s.length() == 2); Note: std::string 's c_str() member will always append a null character to the returned char buffer; However, std::string 's data() member may or may not append a null character to the returned char buffer. Be careful of operator+= One thing to look out for is to not use operator+= with a char* on the RHS. It

This is from a small library that I found online: const char* GetHandStateBrief(const PostFlopState* state) { static std::ostringstream out; // ... rest of the function ... return out.str().c_str() } In my code I am doing this: const char *d = GetHandStateBrief(&post); std::cout<< d << std::endl; Now, at first d contained garbage. I then realized that the C string I am getting from the function is destroyed when the function returns because std::ostringstream is allocated on the stack. So I added: return strdup( out.str().c_str()); And now I can get the text I need from the function. I have

I saw use of this pattern to concatenate onto a string in some code I was working on: sprintf(buffer, "%s <input type='file' name='%s' />\r\n", buffer, id); sprintf(buffer, "%s</td>", buffer); and I'm fairly certain it's not safe C. You'll notice that buffer is both the output and the first input. Apart from the obvious possibility of a buffer overflow , I believe there is no guarantee that buffer doesn't get changed between the start and the end of the function (i.e., there is no guarantee as to what the state of buffer will be during the execution of the function). The signature of sprintf