Stev.Org

C++ - Prevent an object by being copied with boost::noncopyable

james@stev.org — Thu, 22 Aug 2013 07:00:00 +0100

Sometimes in C++ it can be an advantage for making a class noncopyable for various reasons. This can be acomplished by inherting a class from the boost libraries. Which is called boost::noncopyable. This will force the classes copy constructors to be private.

class MyClass : private boost::noncopyable
{
	public:
		MyClass() { }
};

By doing this. It will prevent the following from being able to compile because a copy is passed to the function. A reference should be passed instead. This will also prevent operations such as "a = b".

void func(MyClass a)
{

}

int main(int argc, char **argv)
{
	MyClass a, b;
	
	func(a);

	return 0;
}

Some advantages of using this include.

Boost::noncopyable prevents the classes methods from accidentally using the private copy constructor
It is more explicit and descriptive in the intent. Using private copy functions is an idiom that takes longer to spot than noncopyable.
It is less code / less typing / less clutter / less room for error (the easiest would be accidentally providing an implementation).
You don't have to write your own private copy constructor.
Attempting to copy will catch issues sooner. eg at compile time.

One disadvantage is that there is a small overheat of the class inheirtance.

Bash - Upgrading lots of git repos.

james@stev.org — Fri, 16 Aug 2013 19:33:00 +0100

Here is a nice example of how to execute a git command on multiple git repositories one after another. Assuming that they are all in the same directory.

#!/bin/bash

for i in * ; do
	if [ -d $i ] ; then
		if [ -d $i/.git ] ; then
			echo Updating $i ....
			(cd $i ; git pull)
			echo
		fi
	fi
done

Pyton - How to find out if a key exists in a dictionary

james@stev.org — Tue, 09 Apr 2013 08:00:00 +0100

Another simple python example which is how to find out if a key exists in python

Just use "if" and "in" like in the following example

>>> x['item1'] = 0
>>> if 'item1' in x:
...  print "True"
...
True

Some of the mistakes that I have seen is this will "appear" to work correctly but in fact it does not. Have a look at these examples. You can see here that it will fail because it is testing the value rather than the key.

>>> x['item1'] = 1
>>> if x['item1']:
...  print "True"
...
True
>>>

>>> x['item1'] = 0
>>> if x['item1']:
...  print "True"
...
>>>

Python - json encode / decode

james@stev.org — Thu, 04 Apr 2013 08:00:00 +0100

This is a short example to be able to encode / decode json inside python. Its actually really easy to do.

You will first need to import the json library using

import json

Encoding to json

>>> x = {}
>>> x['1'] = 0
>>> x['2'] = 0
>>> x['3'] = 0
>>> x['4'] = 0
>>> json.dumps(x)

Deocoding from json

>>> x = json.loads('{"1": 0, "2": 0, "3": 0, "4": 0}')
>>> print x
{u'1': 0, u'3': 0, u'2': 0, u'4': 0}
>>>

It really is as simple as that!

C++ - std::vector add, insert, remove, process, erase, swap, sort, clear

james@stev.org — Tue, 02 Apr 2013 08:00:00 +0100

Here is some examples of how to use std::vector with string for most of the common operations that can be performed on std::vector.

The following example assume the following has been declared

std::vector<std::string> vec;

Adding Items

vec.push_back("Item 1");
vec.push_back("Item 2");
vec.push_back("Item 3");
vec.push_back("Item 4");
vec.push_back("Item 5");

Adding Items to front

vec.insert(vec.begin(), "Front 2");
vec.insert(vec.begin(), "Front 1");

Remove Last Item

vec.pop_back();

Remove Last Item

vec.erase(vec.end());

Remove First Item

vec.erase(vec.begin());

Process All Items

for(std::vector<std::string>::iterator it = vec.begin(); it != vec.end(); it++)
{
  printf("%s\n", it->c_str());
}

Process All Items

for(size_t i = 0; i < vec.size(); i++)
{
  printf("%s\n", vec[i].c_str());
}

Reverse The Order - Note you can also just run the above backwards instead.

for(size_t i = 0; i < vec.size() / 2; i++)
{
  std::string tmp = vec[i];
  vec[i] = vec[vec.size() - i - 1];
  vec[vec.size() - i - 1] = tmp;
}

Sorting

std::sort(vec.begin(), vec.end());

Find and Remove an item

for(std::vector<std::string>::iterator it = vec.begin(); it != vec.end(); it++)
{
  if (*it == "Item 2")
  {
    vec.erase(it);
    break;	//it is now invalud must break!
  }
}

Clear All Items

vec.clear();

C++ - Why you need a copy constructor

james@stev.org — Fri, 29 Mar 2013 10:29:00 +0100

In C++ you may come across an issues where you need to use a copy constructor. This is because when a class is assigned from one variable to another it has to copy the values across. If we are dealing with pointers that are inside the class then the pointer will be copied. So this can create and issue if the pointer is deallocated in the destructor. Since now there is two copied of the same pointer which is going to be deallocated twice. This will result in a common issue such as a double free.

In this short program you can see the effect here that will cause a double free. In this case I am using "malloc" to keep the example short. The following program will crash when the main function returns as it will call free from the destructor twice on the same pointer value.

class MyClass {
    public:
        char *buf;
		size_t buf_len;

        MyClass(size_t len) {
            printf("Alloc\n");
			buf_len = len;
            buf = (char *) malloc(len * sizeof(buf));
        }

        ~MyClass() {
            printf("Free\n");
            free(buf);
        }
};


int main(int argc, char **argv) {
    MyClass x = MyClass(4096);
    MyClass y = x;

    return 0;
}

To get another the issue above in C++ we must use a copy constructor which will allow us to override the default functionality when the class is copied in order to allocate and copy the contents of the buffer and a new pointer which will completly seperate the source class from the new class that is being assigned.

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

class MyClass {
    public:
        char *buf;
		size_t buf_len;

        MyClass(size_t len) {
            printf("Alloc\n");
			buf_len = len;
            buf = (char *) malloc(len * sizeof(buf));
        }

        ~MyClass() {
            printf("Free\n");
            free(buf);
        }
        
        MyClass(const MyClass &source)
        {
        	buf_len = source.buf_len;
        	buf = (char *) malloc(buf_len * sizeof(buf));
        	memcpy(buf, source.buf, buf_len);
        }
};


int main(int argc, char **argv) {
    MyClass x = MyClass(4096);
    MyClass y = x;

    return 0;
}

C++ - Boost Optional

james@stev.org — Wed, 27 Mar 2013 17:21:00 +0100

Using boost::optional can be an advantage in certain situation. In C++ it effectivly works by being able to turn any datatype into a nullable value. It works much the same way as returning a null pointer to an object but without using a pointer. Instead this will work by being able to return an object which may or may not valid.

It is typically used to return a value from a function where the function may fail in certain situations. If you attempt to use the optional value which has not been set it will fail and the program will abort. This of course is also useful for debugging in order to catch issues sooner rather than later by accessing various variable that may not have valid values.

It can of course also be used to pass optional paramaters to functions where you may not want to use operator overloading.

Here is an example of it converting an string to an int which will obviously fail on one of the strings.

#include <stdio.h>
#include <string>

#include <boost/optional.hpp>

boost::optional<int> func(const std::string &str)
{
        boost::optional<int> value;
        int tmp = 0;

        if (sscanf(str.c_str(), "%d", &tmp) == 1)
                value.reset(tmp);

        return value;
}

int main(int argc, char **argv)
{
        boost::optional<int> v1 = func("31245");
        boost::optional<int> v2 = func("hello");

        if (v1)
                printf("%d\n", v1.get());
        else
                printf("v1 not valid\n");

        if (v2)
                printf("%d\n", v2.get());
        else
                printf("v2 not valid\n");

        return 0;
}

The output of the above is

31245
v2 not valid

Linux - What and how to kill a zombie process

james@stev.org — Fri, 01 Mar 2013 10:12:00 +0100

What is a zombie?

A zombie process is simply a process that has exited but its parent has not yet read the processes exit code. Since the process has exited it does not have any open files or uses any memory in fact the only resources it is using is a entry in the task list. So in most Linux systems will mean that it is using around 4k-8k of memory.

Until the parent process reads the exit code the zombie will exist. Typically this points to a software bug in the parent process or an issue that caused the child (which is now the zombie) to exit unexpectedly. Which would also point to a bug or issue in the program. In either case the parent process should have actually dealt with the error an acted on it to read the exit status of the process which will clean up the zombie process and allow it to exit.

Why is there any issue?

Since the program isn't really using any resources it really doesn't cause any issues. However if you have a lot of zombie's being generated inside a system due to a bug in the software it will cause an issue because it is still running as a process and sooner or later you will hit the limit of the maximum number of processes permitted to run in the system. If this limit is reached you will not be able to start any more processes. This means you won't be able to run commands from the command line any more.

Why does kill now work on the zombie process?

Kill simply does not work on a zombie process since it is in fact already "dead"

How to kill it?

Since the issue really exists in the parent process the solution is to remove the parent process either by killing it or shutting it down. This will cause the child "zombie" processes to get a new parent process which will be the parent of the parent.

If you are working in a complex system you may need to kill several parent process in order to eliminate the zombies until the zombies get a parent process that will read the exit code from the processes which will cause the zombie process to be remove.

Hint: if you use the command "ps axfu" the "f" in the argument list will print the output as a tree which will make finding the parent somewhat simpler.

C - Some Simple Examples of using strcat

james@stev.org — Sat, 16 Feb 2013 11:06:00 +0100

This post shows some simple example of using strcat to join two strings together in C

The msot common example you will find on the internet will work by just making an array that is "big enough" to store both the strings. However this can create problems when the strings you use are too long so it would need these conditions handled correctly in C. So it probably isn't the best example to use.

void basic(char *s1, char *s2)
{
	char str[200] = "";
	
	strcat(str, s1);
	strcat(str, s2);
	printf("basic: %s\n", str);
}

A better example of using strcat is to allocate an array dynamically. In this case on the stack. So this will work slightly better however it can cause a significant amount of stack space to be used and can also cause crashes if the strings are too long. However it will execute very quickly because dynamic allocation of memory on the stack will perform well.

void better1(char *s1, char *s2)
{
	char str[strlen(s1) + strlen(s2) * sizeof(*s1) + 1];
	str[0] = '\0';

	strcat(str, s1);
	strcat(str, s2);
	printf("basic: %s\n", str);
}

A much better example of this is to use malloc / free for the allocation of string. This will be slightly slower than the previoud example but will be able to handler much larger strings and much safer to use. It can of course still crash but only if the machine run's out of memory. How ever this error can be handled to prevent it crashing by changing the call to abort() to use proper error handling.

void better2(char *s1, char *s2)
{
	char *str = malloc(strlen(s1) + strlen(s2) + 1 * sizeof(*s1));
	if (str == NULL)
		abort();
	str[0] = '\0';
	
	strcat(str, s1);
	strcat(str, s2);
	printf("basic: %s\n", str);
		
	free(str);
}

Finally this is an example about joining multiple strings so we can just keep making our string longer and longer or join it from multiple different sources. Note that the following code really needs a check around the realloc function to see if it returns NULL. If it does then it should fail by returning the previous pointer. Or call abort because the system has run out of memory.

char *multiple(char *str, char *s2)
{
	int len;
	char *s;
	if (str != NULL)
		len = strlen(str);
	len += strlen(s2) + 1 * sizeof(*s2);
	s = realloc(str, len);
	strcat(s, s2);
	return s;
}

With the above code we can call it in the following way

char *tmp = multiple(NULL, "Hello ");
	tmp = multiple(tmp, " World");
	tmp = multiple(tmp, " We");
	tmp = multiple(tmp, " Can");
	tmp = multiple(tmp, " Join");
	tmp = multiple(tmp, " strings");
	printf("%s\n", tmp);
	free(tmp);

Debian - Getting sshfs to work

james@stev.org — Thu, 14 Feb 2013 20:23:00 +0100

This is a short guide to get ssh to work on debian. So this should also work with some other linux varients like ubuntu. It can be a very useful tool to be able to access your home directory from a 2nd linux machine or from your raspberry pi. I have been using it so that you can run your normal powerful code editors which the raspberry pi does not have enough resources to run them fast enough.

To Install / Setup

sudo apt-get install sshfs

sudo addgroup $USER fuse

Note: You don't need to add your self to the fuse ground. But it is required if you want to be able to mount / umount the filesystem without root permissions.

To Use

mkdir Raspberry

sshfs <username>@<ip address>:/home/<username>/Raspberry -o uid=1001,gid=1002 Raspberry

Note: in the above you should change the uid and gid to your user id and group id. You can look thoose up in the /etc/passwd and /etc/group files on the machine that you are mounting the remote filesystem on.

To unmount

fusermount -u /home/james/Raspberry/

Another useful tip is that it will also work with ssh key authentication so that you do not even require a password or so that you can have it configured to automount on boot using the crontab.