Coding Friends » C / C++

Function vs Method

genux — Tue, 08 Mar 2011 23:01:46 +0000

The main difference between a function and a method is that a function can live independently of the any instance of a class, where as a method sits within a class.

That is about it, e.g. a function is

int func(int value);
...
 
int main()
{
  cout << funct(3) << endl;
}

whereas a method has to live within a class

class myclass
{
    int myMethod(int it);
};
 
....
 
int main()
{
   myclass theclass;
   cout << theclass.myMethod(4) << endl;
}

Strings

genux — Tue, 08 Mar 2011 22:59:47 +0000

Just a small thing encase anyone else finds this interesting as such.. but you cannot add a set of ” ” strings together in c++ without declaring one being a string.. for example

cout << "hi" + "bye" << endl;

the error would be

error: invalid operands of types ‘const char [3]’ and ‘const char [4]’ to binary ‘operator+’

because c++ treats them both as char[] variables and not as a string, so you need to wrap one up into a string for it to work

cout << string("hi") + "bye" << endl;

Why -> and not *name.type

genux — Tue, 08 Mar 2011 22:55:42 +0000

When you are coding with pointers in c++ and you want to access the function/variable from that pointer deferenced, how come you cannot use something like below.

struct typeT{
   int value1;
};
 
typeT* tt = new typeT;
*tt.value1;

it is because the access element of the variable tt is higher in the compiler and thus it tries to equate

tt.value1

first, which is not a good thing because the tt has not been de-referenced and thus it is just a memory address pointer to the actual object. so you need to do

(*tt).value1

because like in maths the () will be equated first and then the access element part “.” and thus to make it easier

tt->value1

will change to

(*tt).value1

within the compiler.

CS107 – Assignment 2 – Six degrees

genux — Wed, 25 Aug 2010 19:54:32 +0000

This is assignment 2 from a older CS107 course, because the latest course work is held on a UNIX server which in turn you need access to!!.. kinder does not help when you do not have access too!!.. Here is where I got the files from cs107 link, there is a zip file at the bottom of that page which has all of the assignments and handouts etc.

I have included the PDF of the assignment in the above file link, but since the actual assignment includes a few massive files you can download them from the CS107 link of the whole course work that I am using from the cs107 link.

As a note, within my linux setup, I need to setup the environment variable to tell the program to use a Linux little endian by

export OSTYPE=linux

Basically the assignment is to load in cast/movie details (which the base code from the assignment already does for use) and then we are needed to pull out the data from the structure of the file, the structure of the actors is (as taken from the PDF file)

The name of the actor is laid out character by character, as a normal null-terminated C-string. If the length of the actor’s name is even, then the string is
padded with an extra ‘\0′ so that the total number of bytes dedicated to the name is always an even number. The information that follows the name is most
easily interpreted as a short integer, and virtually all hardware constrains any address manipulated as a short * to be even.
The number of movies in which the actor has appeared, expressed as a two-byte short. (Some people have been in more than 255 movies, so a single byte just
isn’t enough.) If the number of bytes dedicated to the actor’s name (always even) and the short (always 2) isn’t a multiple of four, then two additional ‘\0′’s
appear after the two bytes storing the number of movies. This padding is conditionally done so that the 4-byte integers than follow sit at addresses that are
multiples of four.
An array of offsets into the movieFile image, where each offset identifies one of the actor’s films.

with the base of the actors information containing a 4 byte integer value of how many actors are in the block of data and then the following values are in 4 bytes again with the offsets into the block of where the actual data is stored.

So the method that you need to write is to pull in that data from the actorInfo block of memory, and here is my version of it, the method is getCredits and takes the cast member (player) as the method will insert all of the films that cast as been in.

bool imdb::getCredits(const string& player, vector<film>& films) const
{
    int numberOfActors,data;
    char *actorName;
    memcpy(&numberOfActors,(int*)actorInfo.fileMap, 4);
    // loop though the number of actors
    for (int i =2; i < numberOfActors; i++)
    {
        memcpy(&data, ((int*)actorInfo.fileMap)+i,4);
        actorName = ((char*)actorInfo.fileMap + (data));
        if (strcmp(actorName,player.c_str())==0)
        {
            // find the padding lengths
            int actorNameLength = strlen(actorName)+1;
            int movieNumberPad = actorNameLength % 2;
            int fourOffset = (actorNameLength + movieNumberPad + 2) % 4;
            short numberMovies;
            memcpy(&numberMovies,((short*)((char*)actorInfo.fileMap + data + actorNameLength + movieNumberPad)),2);
            for (int j=0; j < numberMovies; j++)
            {
                int movieOffset;
                film theFilm;
                memcpy(&movieOffset, ((int*)((char*)actorInfo.fileMap + data + actorNameLength + movieNumberPad + (j*4) + fourOffset + 2)),4);
                theFilm.title = ((char*)movieInfo.fileMap + movieOffset);
                theFilm.year = 1900 + (int)((char*)movieInfo.fileMap + movieOffset + theFilm.title.length() + 1)[0];
                films.push_back(theFilm);
            }
            return true;
        }
    }
    return false;
}

The block of memory for the movie block is similar to the actor block and as taken from the PDF attached file here is the details of that block of memory,

The title of the movie, terminated by a ‘\0′ so the character array behaves as a normal C-string.
The year the film was released, expressed as a single byte. This byte stores the year – 1900. Since Hollywood is less than 28 years old, it was fine to just store the year as a delta from 1900. If the total number of bytes used to encode the name and year of the movie is odd, then an extra ‘\0′ sits in between the one-byte year and the data that follows.
A two-byte short storing the number of actors appearing in the film, padded with two additional bytes of zeroes if needed.
An array of four-byte integer offsets, where each integer offset identifies one of the actors in the actorFile. The number of offsets here is, of course, equal to
the short integer read during step 3

And once again like the actor block there is a 4 byte integer value that stores how many movies within the block of memory with the next 4 bytes storing the offset into that block of memory, here is my implementation of the method getCast that will take a movie as a parameter and find all of the cast (players) and return that vector list.

bool imdb::getCast(const film& movie, vector<string>& players) const
{
    int numberOfMovies, data;
    film theFilm;
    char *movieName;
    memcpy(&numberOfMovies, (int*)movieInfo.fileMap, 4);
    for (int i = 1; i < numberOfMovies; i++)
    {
        memcpy(&data, (int*)movieInfo.fileMap+i,4);
        movieName = ((char*)movieInfo.fileMap + data);
        theFilm.title = movieName;
        theFilm.year = 1900 + (int)((char*)movieInfo.fileMap + data + theFilm.title.length() + 1)[0];
        if (movie == theFilm)
        {
            int paddingFirst = theFilm.title.length() % 2;
            // paddingSecond = paddingfirst + length of title + 2 (year + \0) and then + 2 for the actors number
            int paddingSecond = (paddingFirst + theFilm.title.length() +2 + 2) %4;
            short numberOfActors;
            memcpy(&numberOfActors, (short*)((char*)movieInfo.fileMap + data + theFilm.title.length() + 2 + paddingFirst),2);
 
            // get the actors offsets and insert into the players list
            for (int k =0; k < numberOfActors; k++)
            {
                int offset;
                memcpy(&offset, ((int*)((char*)movieInfo.fileMap + data + strlen(movieName) + 2 + paddingFirst + 2 + paddingSecond + (k*4))), 4);
                players.push_back((char*)actorInfo.fileMap + offset);
            }
            return true;
        }
    }
    return false;
}

After you have sorted out reading in the information you have to find out if there is a link from actor1 to another actor2 (six degrees) with linking them together the cast that they have been with with the films that they have stared in, so here is my breath search setup as taken from the assignment.

/**
  * @param actor1 - first actor to look for
  * @param actor2 - second actor to look for to link to the first
  * @param db - the imdb database loaded
  */
static bool generateShortestPath(const string& actor1, const string& actor2, const imdb& db)
{
    list<path> partialPaths;
    set<string> previouslySeenActors;
    set<film> previouslySeenFilms;
 
    path actorsFirst(actor1);
    partialPaths.push_front(actorsFirst);
 
    while (!partialPaths.empty() && partialPaths.front().getLength() <=5)
    {
        path frontPath = (path)partialPaths.front();
        partialPaths.pop_front();
        vector<film> actorsFilms;
        db.getCredits(frontPath.getLastPlayer(), actorsFilms);
        for (int filmI=0; filmI < actorsFilms.size(); filmI++)
        {
            film filmData;
            filmData = actorsFilms.at(filmI);
            // not seen the film before
            if (previouslySeenFilms.find(filmData) == previouslySeenFilms.end())
            {
                previouslySeenFilms.insert(filmData);
                vector<string> movieCast;
                db.getCast(filmData, movieCast);
                for (int castI =0; castI < movieCast.size(); castI++)
                {
                    // if not already seen
                    if (previouslySeenActors.find(movieCast.at(castI)) == previouslySeenActors.end())
                    {
                        previouslySeenActors.insert(movieCast.at(castI));
                        path newfrontPath = frontPath;
                        newfrontPath.addConnection(filmData, movieCast.at(castI));
                        if (movieCast.at(castI) == actor2)
                        {
                            cout << newfrontPath << endl;
                            return true;
                        } else
                            partialPaths.push_back(newfrontPath);
                    }
                }
            }
        }
    }
    return false;
}

You can do some speed ups from the assignments PDF file, but they are mainly the icing on the cake and I thought that I would assignment 3 first, so if I do the extras for this I will update this post.

But this was a fun assignment, because of the memory block and finding out the data within it.

struct – setup and memory locations

genux — Fri, 23 Jul 2010 09:47:17 +0000

When you setup a struct within c++, it is kinder like having a array of data and if you want to you can access the internal parts by using some memory pointer location fun!.

Lets say that you have a struct of

struct intvalue {
    int a;
    int b;
};

Just to say that since I am using int(eger) values so that is what I am incrementing by in the pointer arithmetic which is why I am casting the pointer to a integer value.

So lets say that we create a variable of intvalue and setup the values as below

intvalue testvalue;
testvalue.a = 4;
testvalue.b = 5;

We can then pull out the value of a or b, but using memcpy and just outputting to a int(eger) variable as below, the key is the ((int*)&testvalue)+1, this will first convert the testvalue variable to a pointer to memory location and then (int*) casts that pointer to a int pointer, because internally that is what it is, and then just add 1 to it, which points to the second value ( in this case the value of b which is 5)

    int avalue;
    // convert to a int pointer type and then add one to it (to the next array element as such).
    memcpy(&avalue, ((int*)&testvalue)+1,sizeof(int));
    cout << "a value (or is it the b value :) ) " << avalue << endl;

The output would be

a value (or is it the b value :) ) 5

because I am pointing to the second value which is b and thus 5 .

Of course if you just wanted the value of first int (the value of a in this case) you do not add the 1 to the memory location, for example

    memcpy(&avalue, ((int*)&testvalue),sizeof(int));

this time I am just converting the testvalue (casting) to a int pointer and thus pointing to the start of the struct and that is where the int a variable is living .

CS107 – Assignment 1 – Context Free Grammar – Random Sentence Generator

genux — Wed, 14 Jul 2010 14:55:13 +0000

This is assignment 1 from a older CS107 course, because the latest course work is held on a UNIX server which in turn you need access to!!.. kinder does not help when you do not have access too!!.. Here is where I got the files from cs107 link, there is a zip file at the bottom of that page which has all of the assignments and handouts etc.

The basics of a context free grammar is (as taken from the PDF file attached which is the assignment 1 in more details), the tokens as such are the <..> parts of the block, so that you start at and then you print out “The ” and then goto the block to then print out a randomly picked object to then print out the if there is any blocks within the object/verb then do them before heading back to the last word on the block which is “tonight”. That is it, it generates random text .

The Poem grammar
{
<start>
	The <object> <verb> tonight. ;
}
 
{
<object>
	waves	;
	big yellow flowers ;
	slugs ;
}
 
{
<verb>
	sigh <adverb> ;
	portend like <object> ;
	die <adverb> ;
}
 
{
<adverb>
	warily ;
	grumpily ;
}

So the assignment is mainly to get used to compiling up programs within a Linux/Unix environment, I was using qt-creator IDE (which has placed some files within the zip file attached, but it does not effect the directory structure as such). To compile on Linux/Unix as long as there is a Makefile you can just

make

So, the assignment 1 base code reads in the textual files and all is required is to output the text within a random sentence and repeat 3 times, so the start of the code does the looping and calls the doRandomText function which requires as parameters the mapped (map) grammar and where to start ()

  for (int i =1;i <= 3; i++)
  {
      cout << "Version #" << i << endl << endl;
      doRandomText(grammar, "");
      cout << endl << endl;
  }
  return 0;
}
 
// recursive loop in the text and produce randomly generated text
void doRandomText(map<string, Definition> theGrammar, string terminal)
{
    Definition def = theGrammar[terminal];
    assert(def.getNonterminal().size() !=0);
    Production prod = def.getRandomProduction();
    for (Production::iterator prodIter = prod.begin(); prodIter != prod.end(); prodIter++)
    {
        string theText = *prodIter;
        if (theText.at(0)=='<' && theText.at(theText.size()-1)== '>')
            doRandomText(theGrammar, theText);
        else
        {
            if (theText == "," || theText == ".")
                cout << theText;
            else
                cout << " " << theText;
        }
    }
}

The recursive function above basically tries to find the terminal within the grammar definitions and if there is not one, exit the code (assert), else print out the textual data whilst iterating over them, if there is any more terminals within the sentence then goto that terminal by calling this same function.

Here is the output of a run from the program.

./rsg assn-1-rsg-data/excuse.g 
The grammar file called "assn-1-rsg-data/excuse.g" contains 7 definitions.
Version #1
 
 I need an extension because my disk got erased, and I'm sure you've heard this before, but I had to make up a lot of documentation for the Navy in a big hurry, and I'm sure you've heard this before, but my printout was enshrowded in a mysterious fog for three days and then vanished, and I'm sure you've heard this before, but all my pencils broke, and just then I had 7 programs in like, a billion different langauges, and if you can believe it, I just didn't feel like working, and and then if I recall correctly I had to worry about the Winter Olympics, and and then if I recall correctly my disk got erased, and as if that wasn't enough I forgot how to write.
 
Version #2
 
 I need an extension because I got stuck in a blizzard at Tahoe, and then get this, my Mac was enshrowded in a mysterious fog for three days and then vanished.
 
Version #3
 
 I need an extension because I didn't know I was in this class, and then I just didn't feel like working, and I'm sure you've heard this before, but I thought I already graduated, and then, just when my mojo was getting back on its feet, the bookstore was out of erasers, and if you can believe it, I didn't know I was in this class, and and then if I recall correctly my dorm burned down.

Explicit – c++ what is it for ?

genux — Wed, 14 Jul 2010 10:19:59 +0000

The explicit keyword in c++ is make sure that user of your class only creates and uses the class only creates it in the way that you was expecting and not via any references as such.

For example in the following code example

class mainClassWith {
public:
    // this basically will setup the internal_value equal to the value that is passed from the user
    explicit mainClassWith(int value) : internal_value(value) {} ;
 
    int internal_value;
};
 
int functionWith(const mainClassWith &theClass)
{
    cout << "the value with " << theClass.internal_value << endl;
}

The functionWith will take a parameter of mainClassWith of which has a explicit keyword on its constructor, this means that if we try and do something like

    mainClassWith mainWith(4);
 
    functionWith(mainWith);

then the compiler will compile and also the output would be printed to the screen of “the value with 4″, but since we know that the mainClassWith takes a integer value as a constructor and try to bypass any object creation of that mainClassWith and try and do this

functionWith(3);

then the compiler will complain because we cannot setup a mainClassWith on the fly like this and let the compiler pass a value of “3″ to the class and hope that it works!!!, we have explicitly declared that the constructor must be initialised before using.

But if we did take off the explicit keyword as in the class example below.

class mainClassWithOut {
public:
    // this basically will setup the internal_value equal to the value that is passed from the user
    mainClassWithOut(int value) : internal_value(value) {} ;
 
    int internal_value;
};
 
int functionWithout(const mainClassWithOut &theClass)
{
    cout << "the value without  "<< theClass.internal_value << endl;
}

then we are able to call the new function (functionWithout) without actually setting up the object and allow the compiler to make up its own instance of that object and pass to the function.

functionWithout(5);

would work and the output would be “the value without 5″ which is correct, but the compiler and created the mainClassWithout object and setup with the value of 5 via its constructor, which if there was a few different constructors etc then how would you be sure that the correct constructor was called and thus would the value that you want back from the class really be 5, it could be 0 and another value be that 5!!.