Sometime it can be a problem when working with network protocols or any sort of client / server communications that use text based protocol it can be a problem to transmit certain types of data which contain quotes or other types of charaters. It also has a simalar problem for storing data in ini files.

There is quite a simple solution to this. Encode the data some how to send the data encoded and decode it at the other end. It would probably be better to use the well known base64 encoding but if you don't have an implementation of it avilable the following can work just as well.

The encoder

std::string HexEncode(std::string str) {
	std::string tmp;
	const char *c = str.c_str();
	char buf[3];
	
	while(*c != 0) {
		sprintf(buf, "%02X", (unsigned char) *c);
		tmp += buf;
		c++;
	}

	return tmp;
}

The decoder

std::string HexDecode(std::string str) {
	std::string tmp;
	const char *c = str.c_str();
	unsigned int x;
	
	while(*c != 0) {
		sscanf(c, "%2X", &x);
		tmp += x;
		c += 2;
	}
	
	return tmp;
}

The only problem with the above is that it does double the size of the data once it is encoded but since most other encoding like base64 or uuencoding.

This is a quick guide to write a C++ std::map<string, string> to a file then read the contents back again. It is useful for saving settingss eg a key value / pair to a config file then reading the back again.

Writing the file is easyier than reading since no parsing is involved. To make this happen all we have to do is open a file then for each item just fprintf to the file then close it again.

int WriteFile(std::string fname, std::map<std::string, std::string> *m) {
	int count = 0;
	if (m->empty())
		return 0;

	FILE *fp = fopen(fname.c_str(), "w");
	if (!fp)
		return -errno;
	
	for(std::map<std::string, std::string>::iterator it = m->begin(); it != m->end(); it++) {
		fprintf(fp, "%s=%s\n", it->first.c_str(), it->second.c_str());
		count++;
	}
	
	fclose(fp);
	return count;
}

Reading the file is a little more complex. All that needs to happen here is to opent he file read from it. then for each line parse the key / pair out of the text file and add them back to the map. A quick explenation of the string parsing is below. I also find getline is useful for functions such as these so that you don't need to know the length of the line in the text file before reading it.

int ReadFile(std::string fname, std::map<std::string, std::string> *m) {
	int count = 0;
	if (access(fname.c_str(), R_OK) < 0)
		return -errno;
	
	FILE *fp = fopen(fname.c_str(), "r");
	if (!fp)
		return -errno;
	
	m->clear();
	
	char *buf = 0;
	size_t buflen = 0;
	
	while(getline(&buf, &buflen, fp) > 0) {
		char *nl = strchr(buf, '\n');
		if (nl == NULL)
			continue;
		*nl = 0;
		
		char *sep = strchr(buf, '=');
		if (sep == NULL)
			continue;
		*sep = 0;
		sep++;

		std::string s1 = buf;
		std::string s2 = sep;
		
		(*m)[s1] = s2;

		count++;
	}

	if (buf)
		free(buf);
	
	fclose(fp);
	return count;
}

The first part of the string parsing is simply to remove the newline's from the end of the file. Since this is the end of the string we can simply shorten the string by marking the newline as a NULL.

char *nl = strchr(buf, '\n');
if (nl == NULL)
 continue;
*nl = 0;

The 2nd part that looks a little more complex is to split the line of text we have read into two strings on the '=' char. Since we have a pointer to the start of the string when we find the '=' sign and change it to NULL we turn the first string into everything before the '='. Then when we increment the pointer to where the '=' was we have out 2nd pointer (sep) now pointing at the value section or the part of the original data after the equals.

char *sep = strchr(buf, '=');
if (sep == NULL)
	continue;
*sep = 0;
sep++;

Then all we do is convert the string's back into C++ / std::string and add them to our map and move into the next line.

In a C program it can be useful sometimes to know if the stdin / stdout / stderr is actually connected to a termianl or not. There is a function alled isatty() which is dedicated to detecting this. An example is below.

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

int main(int argc, char **argv) {
    if (argc < 2) {
        printf("ERROR: Need a file descriptor\n");
        exit(0);
    }
    printf("%d\n", isatty(atoi(argv[1])));
    return 0;
}

This is a short example of using the function atof to convert from a string to float. It is also worth pointing out that this function really returns a double instead of a float and should probably be avoided since it does not support any form of error handling. So strtod should be used instead.

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


int main(int argc, char **argv) {
        char *str = "123.45";
        double val1 = atof(str);
        float val2 = atof(str);

        printf("%s -> %f\n", str, val1);
        printf("%s -> %f\n", str, val2);

        return 0;
}

This function should probably be avoid since it does not have any error handling and the strtol should be used instead. However it is a quick and dirrty way of converting strings to int's

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


int main(int argc, char **argv) {
        char *str = "12345";
        int val = atoi(str);

        printf("%s -> %d\n", str, val);

        return 0;
}