Our second day takes us to Oosterscheldekering, Ypres, and Dunkirk.

Oosterscheldekering (Eastern Scheldt storm surge barrier)

We began our day two heading back into the Netherlands, to a network of storm surge barriers, designed to protect the Netherlands from flooding. Large sets of doors can open and close to control the water flow coming in from the ocean. They’re important because most of the Netherlands sits a few metres above sea level or lower, and thus are prone to flooding.

As we drove in the area of Oosterscheldekering, we encountered a lot of windmills spinning noticeably in the wind. And I wondered where all the old traditional windmills went, as in the ones with a tower made of brick with four rectangular fan blades . Netherlands has a stereotype of having a lot of them. We barely saw any of them and then it occurred to me that most of them were probably upgraded to use modern technology.

Ypres

Our next destination, Ypres, is known for the many battles that occurred there during the First World War, where the Germans introduced chemical weapons in the battlefield in the form of poison gas. During the course of the war, the town was destroyed, mostly by artillery fire.

The town was rebuilt after the war using German war reparations, with the main square following the original design as closely as possible. The In Flanders’ Fields Museum (the big building in the above picture) is a museum dedicated to the First World War.

Dunkerque (Dunkirk)

Our final destination for the day was the French port city of Dunkirk, known for the role it played during the evacuation of Allied forces from France. The Germans had achieved a breakthrough in France and had surrounded the bulk of Allied forces around Dunkirk. The German airforce was tasked to destroy these forces, so that the Germany army could conserve its ground forces for other operations, but the Germans failed to destroy the Allied forces and over 338000 soldiers were successfully evacuated to Britain.

That night, the locals were having a festival, called the “Bal du Chat Noir”, probably loosely translated as “The Black Cat Ball”. It’s so obscure that as of this writing, an English Wikipedia article for this festival doesn’t even exist. The French Wikipedia describes it as a festival to celebrate the opening of the carnival season (i.e. the Christian Carnival), and that it’s local to Dunkirk.

From what I can tell, it’s kind of like the Carnival in Cologne, where people party in the streets dressed up in costumes. There’s no shortage of reasons for people to party!

Stay tuned for day 3!

• Oosterscheldekering
• Ypres
• Dunkirk

The Hague (Den Haag)

The first stop is The Hague in the Netherlands. It’s the home of the International Court of Justice (pictured above). This is the international court that resolves international disputes that the UN is involved in. It was involved in well known cases such as the International Criminal Tribunal for Rwanda to judge the perpetrators of the Rwandan genocide, and the International Criminal Tribunal for the former Yugoslavia to judge the perpetrators of crimes committed during the internal struggles in Yugoslavia that eventually led to its dissolution.

For lunch, we searched around for something to eat and we could try some herring since that’s a popular dish in the Netherlands. We found a street food stall near us not far from where we were and proceeded to go inside and order. One problem though… the entire menu was in Dutch and there was no English to be found anywhere. We stood there looking confused for a moment, before I piped up and simply asked the staff (knowing that the Netherlands has a very high degree of English literacy) what we should order. He simply replied, “herring sandwich!”. It’s raw herring preserved in a brine in a sandwich along with condiments such as raw onions and pickles. It’s got a nice fishy freshness to it (like sashimi), but a saltier and more sour flavour because of the brine. This is going to be one of those foods that I’ll crave once I leave and can’t get anywhere else.

Another cool place to visit in The Hague is the Madurodam – it’s a park built purely on minatures. Imagine famous landmarks in the Netherlands, like the canals of Amsterdam, old town city squares, and palaces, but in miniature form! As a fan of Lego, I can definitely appreciate looking at miniatures!

Rotterdam

Next, we drove to Rotterdam in the Netherlands and stopped by the Market Hall for more food (I’m always down to eat). This time, we had yet another Dutch speciality: the stroopwafel. It’s hard to say no to two thin crispy wafers with gooey caramel in between.

And because I really enjoy eating protein, I couldn’t resist trying some cured meat. I think this is more of a Spanish thing as opposed to Dutch thing though. I found the flavour way too salty for my tastes (and I use a lot of salt when cooking), but I’m not sure what it’s supposed to taste like.

The market hall also has a nice selection of spices – kind of apt considering their colonial past trading spice and other goods in the Dutch East Indies.

And of course cheese! It’s so nice to see all the wheels of cheese, in all these different colours and sizes.

Baarle-Hertog / Baarle-Nassau

After leaving Rotterdam, we headed towards Belgium – well kind of. The cool thing about Baarle-Hertog / Baarle-Nassau is that a border between Belgium and the Netherlands cuts right through the town in seemingly random spots. You could just be walking down the street along the main avenue of the town and randomly end up in the Netherlands, then in Belgium, and then back again.

On our way out of the town, we noticed lane lines that we hadn’t seen before in North America. At first, we didn’t know why the lines were painted like that, but upon closer analysis, the road is simply a road shared by both cars and bicycles and the red section shows where the bikes should be, and the grey area is the section where cars should be when passing a bicycle. By allocating a space for the car to pass, the cars don’t get too close to the cyclists, thus reducing the risk of an accident. How cool!

Antwerp

Soon, we were fully in Belgium in the city of Antwerp and took a stroll in the old town square. The buildings here look pretty Belgian because of the way the roof inclines – it’s as if there are little steps as opposed to a smooth incline (so-called stepped gables).

This concludes our successful first day of the trip! On day two, we will travel to Oosterscheldekering, Ypres, and Dunkirk.

Photos

• The Hague
• Rotterdam
• Baarle-Hertog
• Antwerp

This post is about deploying an instance of Seafile using Docker on a non-standard port (i.e. not 80 and 443). The reason to deploy the app on a non-standard port is usually because there is already another webserver running on that port (in my case Apache 2). In such scenarios, it is necessary to set up a reverse proxy so the Seafile port can be exposed by Apache on ports 80/443. Under typical circumstances, deploying Seafile on a standard port would mean that the app would host itself without the need for Apache 2 at all. This post also assumes Ubuntu 16.04 as the operating system, but in theory should apply to other Linux OS’s.

The process can be split into multiple parts:

1. Setup Docker
2. Deploy Seafile
3. Configure Apache 2
4. Setup systemd
5. Setup e-mail (optional)
6. Backing up the image
7. Troubleshooting

Setup Docker

This guide won’t go into depth on how to setup Docker, but rather the setup guide and more information about what Docker is can be found here: https://docs.docker.com/get-started/

Deploy Seafile

The key page in the Seafile documentation for deploying Seafile within Docker can be found here: https://github.com/haiwen/seafile-docker. The command I used is as follows:

docker run -d --name seafile \
  -e SEAFILE_SERVER_HOSTNAME=seafile.example.com \
  -e SEAFILE_ADMIN_EMAIL=me@example.com \
  -e SEAFILE_ADMIN_PASSWORD=a_very_secret_password \
  -v /opt/seafile-data:/shared \
  -p 8000:80 \
  seafileltd/seafile:latest

I recommend setting up Seafile with an actual secret password because it’s not easy to change once it’s set up.

Note that the port argument shows 8000:80. It means that Docker will use the host port 8000 and the container will use port 80 – meaning that using Docker will interpret requests from my host OS on port 8000 as requests on port 80 in the container. 8000 was used on my setup because port 80 was already used.

Once the command is executed, the necessary files will be downloaded and the container will start and will be accessible on port 8000.

There is also an option to setup Seafile with an SSL cert from Let’s Encrypt, but I didn’t do this because I already had a cert that I wanted to reuse.

Once the server is up, navigate to https://seafile.example.com/sys/settings/ and change SERVICE_URL and FILE_SERVER_URL to match your domain name.

Configure Apache 2

Adding a reverse proxy on Apache 2 will allow Apache 2 to route requests to port 8000, which will go to port 80 in the container. The main reference for this section is this: https://manual.seafile.com/deploy/deploy_with_apache/. This is done by adding a new site to Apache 2. The following configuration assumes that a LetsEncrypt SSL certificate is used.

cd /etc/apache2/sites-available
sudo nano seafile.conf

<IfModule mod_ssl.c>
<VirtualHost *:443>
    ServerName seafile.example.com
    ServerAdmin me@example.com

    RewriteEngine On

    # ModSecurity does not process requests.  There is a hard limit of 1 GB
    # with ModSecurity.
    SecRuleEngine Off

    # Whitelist internal IPs for mod_evasive
    DOSWhitelist 192.168.1.*

    <Location /media>
        Require all granted
    </Location>

    # Stuff for seafile server
    ProxyPass /seafhttp http://127.0.0.1:8082
    ProxyPassReverse /seafhttp http://127.0.0.1:8082
    RewriteRule ^/seafhttp - [QSA,L]

    # Stuff for seahub
    SetEnvIf Authorization "(.*)" HTTP_AUTHORIZATION=$1
    ProxyPreserveHost On
    ProxyPass / http://127.0.0.1:8000/
    ProxyPassReverse / http://127.0.0.1:8000/

    ErrorLog ${APACHE_LOG_DIR}/seafile_error.log
    CustomLog ${APACHE_LOG_DIR}/seafile_access.log combined

    Include /etc/letsencrypt/options-ssl-apache.conf

    SSLCertificateFile /path/to/cert/file.pem
    SSLCertificateKeyFile /path/to/cert/key/file.pem
</VirtualHost>
</IfModule>

I’ve added my local domain to the whitelist so that mod_evasive doesn’t think my local host is a threat.

There are two sets of ProxyPass and ProxyPassReverse lines. The reason for this is that Seafile is split up into Seahub and Seafile, where one uses port 8082 (by default), while the other uses 8000. These two lines are essentially what allows Apache to read requests from port 443 and pass them on to the container.

Once the file is saved, execute the following

sudo a2ensite seafile.conf
sudo service apache2 reload

Navigating to the site at the Apache 2 defined port should now load Seafile without having to go to port 8000.

Setup systemd

systemd allows the Docker container to be started up on boot, and be controlled like this:

sudo service seafile start/stop/restart

The configuration is as follows:

sudo nano /etc/systemd/system/seafile.service

[Unit]
Description=Seafile Server
After=network.target mysql.service

[Service]
Type=oneshot
ExecStart=/usr/bin/docker container start seafile
ExecStop=/usr/bin/docker container stop seafile
ExecReload=/usr/bin/docker container restart seafile
RemainAfterExit=yes
User=root
Group=root

[Install]
WantedBy=multi-user.target

Once the configuration is saved, shut off the existing running instance of Seafile and then let systemd start it up for you.

sudo systemctl daemon-reload
sudo service seafile start

At this point, Seafile should start automatically on boot, with Apache 2 doing a reverse proxy to the true Seafile port.

Setup e-mail (optional)

Optionally, Seafile can be configured to send e-mails. The reference is here: https://manual.seafile.com/config/sending_email/. The config file should be under:

/opt/seafile-data/seafile/conf/seahub_settings.py

I happen to be using Gmail SMTP, so at the end of the file I’ve added

EMAIL_USE_TLS = True
EMAIL_HOST = 'smtp.gmail.com'
EMAIL_HOST_USER = 'me@example.com'
EMAIL_HOST_PASSWORD = 'password'
EMAIL_PORT = 587
DEFAULT_FROM_EMAIL = EMAIL_HOST_USER
SERVER_EMAIL = EMAIL_HOST_USER

Backing up the image

After setting everything up, you’ll probably want to backup the Docker image. First, print out the list of running containers

sudo docker ps

Then take a snapshot of the current running state:

docker commit -p <container ID> <whatever you want to call this snapshot>

Running this command lists all the images and should show this newly saved image:

sudo docker images

I don’t have a private docker repository, so I saved the image to the disk and backed up the file by doing the below. Just make sure to actually move the image to an actual backup location.

sudo docker save -o <whatever path you want>/<filename>.tar <the name used earlier>

The image should be backed up now. To restore the image, it’s a matter of running this:

sudo docker load -i <path to the backup file>

Listing the images as above should show that the image was successfully loaded. Running this starts it back up again.

sudo docker run <container name>

Troubleshooting

Seafile logs can be helpful if it doesn’t start up correctly. These can be found at:

/opt/seafile-data/logs/seafile

There may be a need to ssh into the Docker container. The command for that is:

sudo docker exec -it seafile /bin/bash

Changing of the Guard

The guards marched from the National Defense Headquarters to Parliament Hill (about 1.2 km).  The guards marched wearing their uniforms in some 30 degree Celsius weather.  Up close, sweat on their face could be seen dripping down.  They marched in playing their instruments.  The soldiers went in formation and each soldier’s attire was inspected to ensure that they were each fit to stand guard.  This process took about 30-45 minutes.  It was cool seeing these guards dressed up in this kind of uniform.  I didn’t even know Canada had these.

Peace Tower

After the show, we went up to the Peace Tower, the clock tower in front of the building.  At the top, we could see pretty much all of the Ottawa-Gatineau area.  Ottawa has a quite even balance of trees, buildings, and water.  I don’t really know how to define it, but the view just seems more interesting that just seeing endless buildings.  I suppose having some green and blue makes the picture more appealing to the eye.  Bridges across the river adds a nice touch.  There also aren’t a lot of tall builds either, which definitely helps in keeping the view clear.

Originally, we wouldn’t have been able to go up the Peace Tower and come back in time for the tour, but my cousin said that when the tour group comes in, they would have to pass through security.  We had already done that to go up the Peace Tower, and so after we came down the tower, we stayed in the secured area and met up with the tour group once they came in through security.

The Memorial Chamber

Just below the Peace Tower was the Memorial Chamber.  In this chamber, there is a war memorial.  The significance of this one is that there is a book that has the list of names 66 655 Canadians who lost their lives during the First World War.  A second book was also added for the Second World War.  Every day at 11am, coinciding with the time that the First World War ended, a page is turned.  This allows for each page in the book to appear at least once during the whole year.

Inscribed on the walls in this chamber is the famous poem In Flanders Fields by John McCrae along with the locations where battles occurred such as Ypres, Passchendaele, Cambrai, Somme, among others.

The House of Commons

The House of Commons is where the elected Members of Parliament go whenever there is a meeting.  This is where major government legislation is introduced.  Whenever there is a meeting, this is the chance for all the elected members representing their political parties get the chance to debate topics such as how government money should be spent.  At the top of the room, there are additional seats for any spectators for whenever parliament is in session.

Library of Parliament

In terms of old libraries, this one is probably as old as it gets in Canada.  This is a key information source for the Canadian Parliament.  Occasionally, MP’s will come here to do research on various subjects.  In 1916, there was a fire that burned down the parliament except this room.  Therefore, this is the oldest part of the entire building (constructed in 1876).  Naturally, architectural style used in this building is a lot different that the newer part of the building.

The Senate

The Senate meet in a separate location within the parliament.  Here, senators examine bills proposed by the Government.   When the senate is in session, senators debate the bills and bills must pass the senate in order to become a law.  A special thing to note about this room is that because reconstruction of the parliament building began in 1916, the general mood of the population was that they were sick of war.  Therefore, much of the artwork in the room revolves around this.  Paintings of the war hang above the seats in the senate.  They are a constant reminder of the horrors of war.

Next Destination…Thousand Islands!

After the tour, we had lunch and then we made our way to a place called Thousand Islands for a boat tour.  I heard that there was an actual castle on one of those islands.  I didn’t even know Canada had actual castles.  I always though castles were a European thing.

More photos here

asm (seldom used)

• Used to insert assembly language commands directly into the code. This function is very tricky to use even for professional programmers and can cause portability issues.
  

  asm(“instruction”);

auto

• Used to declare local variables but is purely optional.
  

  auto int i = 5;

  The previous declaration thus has identical meaning to the following declaration.

  int i = 5;

bool (C++ only)

• Used to declare a Boolean logic variable; a variable that can have the value true or false. This variable type is normally 8 bits (1 byte) long.
  

  bool t = true;

break

• Used to break out of a loop independant of the loop condition. Also, used to finish a switch statement, keeping the program from “falling through” to the next case in the code.
  

  while(x < 100)
  {
      if(x < 0)
           break;
      cout << x << endl;
      x++;
  }
  

case

• Used as a label to declare a single test in a switch statement.
  

  case 1: command1;
          command2;
          break;
  

catch (C++ only)

• Used to handle exceptions generated by a throw statement.
  

  catch(const char* e)
  {
      //handle exception
  }
  

char

• Used to declare character variables. This variable type is normally 8 bits (1 byte) long.
  

  char c = ‘h’;

class (C++ only)

• Used to define a new class. Members of the class are private by default unless listed under the protected or public labels.
  

  class class-name : inheritance-list
  {
      public:
          public-members-list;
      protected:
          protected-members-list;
      private:
          private-members-list;
  } object-list;
  

  • class-name is the name of the class that is being created.
  • inheritance-list is the optional list of classes inherited by the new class.
  • public-members-list is the list of public members of the class.
  • protected-members-list is the list of protected members of the class.
  • private-members-list is the list of private members of the class.
  • object-list is an optional list used to immediately instantiate 1 or more instances of the class.

  class Date
  {
  public:
      void display();
  
  private:
      int day;
      int month;
      int year;
  }
  

const (C++ only)

• Used to tell the compiler that a certain object should not be modified once it has been initialized.
  

  const int i = 5;

• Used to declare a pointer so that the value of the pointer (the memory location to which it points) can be modified, but the data in the memory location cannot be changed.
  

  const int* j = new int(3);

• Used to declare a pointer so the that value of the pointer (the memory location to which it points) cannot be modified, but the data in that memory location can be changed.
  

  int* const j = new int(3);

• Used to declare a member function that does not modify the object’s state, meaning that it should be used for methods like print so that data in the object cannot be changed accidentally. If and attempt is made to modify the object in any way, a compilation error will be triggered.
  

  void print(bool verbose) const;

const_cast (C++ only, seldom used)

• Used to remove the const protection on a variable as long as the original variable was not declared as a const. The target type must be the same as the original type.
  

  const_cast<target_type> (object);

continue

• Used to jump to the next iteration of a loop. The following example will print out all of the numbers from 1 to 20 except for 10.
  

  for(int i = 0; i < 21; i++)
  {
      if(i == 10)
          continue;
      cout << i << endl;
  }
  

default

• Used as a label to declare the default case of a switch statement.
  

  case 1:  command1;
           command2;
           break;
  
  default: command1;
           command2;
           break;
  

delete (C++ only)

• Used to free memory allocated for a pointer back to the heap. The argument should have been allocated through a call to new. To delete an array, use the following form of delete: delete[]
  

  delete p;
  delete[] pArray;

do

• Used to create a loop that is executed at least once. The terminating condition is tested at the end of the loop.
  

  do
  {
      cout << "hello worldn";
      i++;
  } while(i < 5)
  

double

• Used to declare a double-precision floating-point type variable. This variable type is normally 64 bits (8 bytes) long.
  

  double d = 12.55;

dynamic_cast (C++ only, seldom used)

• Used to cast from one type to another with a check performed at runtime. If the cast types are incompatible, NULL is returned.
  

  dynamic_cast<target_type> (object);

else

• Used for an alternative condition in an if statement.
  

  if(i == 1)
  {
      // do something
  }
  else
  {
      // do something else
  }
  

enum

• Used to define an enumerated type. Each of the names in the name-list are given a distinct value. This should be used in place of defining variables using “magic numbers” (eg. int Monday = 0, int Tuesday = 1, etc).
  

  enum name {name-list};

  • name is the name of the enumerated type that was created
  • name-list is the list of names of the elements

  enum weekdays {Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday};

explicit (C++ only)

• Used to make sure that a constructoor is only used for the creation of new values and not used for the implicit conversion between two different types. It will only be be used if the initialization exactly matches the call to that constructor. This keyword is only needed with one-argument constructors.
  

  class vector
  {
      ...
      explicit vector(int v);
      ...
  }
  

  Using this keyword, some mysterious errors can be caught by the compiler like the following:

  vector<int> v(10);
  v = 5; // error, meant to write v[0] = 5
  

  The problem in this code if the explicit keyword was not specified is that the v = 5 statement would invoke the constructor, creating a new vector of size 5 and destroying the old one.

export (C++ only, seldom used)

• Used to export a template to other modules. Most compilers require template definitions to be explicitly specified in the header file since the Comeau C++ compiler seems to be the only compiler that supports this keyword.
  

  // In MyTemplateFunction.h
  template
  void myTemplateFunction(const T &t1);
  
  // In MyTemplateFunction.cpp
  export template
  void myTemplateFunction(const T &t1)
  {
      ...
  }
  

extern

• Used to inform the compiler of variables and functions that are defined outside of the current scope or module. Variables defined as extern will not have space allocated for them since they are defined elsewhere.
  

  extern char* message;

false (C++ only)

• Used to represent the Boolean value false.
  

  bool b = false;

float

• Used to declare a single-precision floating-point type variable. This variable<br> type is normally 32 bits (4 bytes) long.
  

  float f = 3.5;

for

• Used to create a loop that is meant to initialize, test and update a variable.
  

  for(int i = 0; i < 10; i++)
  {
      cout << "i is " << i << endl;
  }
  

friend (C++ only)

• Used to allow another class or function to have access to the private features of that class.
  

  friend void print(bool verbose);
  friend class Vector;

goto (seldom used)

• Used to jump to another location in a function specified by a label. This is generally considered harmful and should not be used unless necessary.
  

  goto labelA;
  ...
  labelA:

if

• Used to create a conditional branch statement so that different code can be executed under different conditions. The conditions are evaluated in the order that they appear in the code.
  

  if (i < 0)
  {
      cout << "i is negative";
  }
  else if(i == 0)
  {
      cout << "i is 0n";
  }
  else
  {
      cout << "i is posativen";
  }
  

inline (C++ only)

• Used to tell the compiler that the function an its body are inserted into the calling code meaning that it has to expand the function in-place instead of just insert a call to the function. Functions that have static data, loops, switches or recursive calls cannot be inlined.
  

  inline int test(int A)
  {
      ...
  }
  

int

• Used to declare an integer type variable. This variable type is normally 32 bits (4 bytes) long.
  

  int i = 3;

long

• Used as a data type modifier for the int and double types to indicate that they may have more bytes then the type has available. This variable type is normally 32 or 64 bits (4 or 8 bytes) long.
  

  long int i = 100000;

mutable (C++ only)

• Used to specify that it is a data field that can be modified even if another part of the data is declared const.

namespace (C++ only)

• Used to create a new scope. Once created, the namespace must be refered to either directly or with the using keyword.
  

     namespace CartoonNameSpace
      {
          int HomersAge;
  
          void incrementHomersAge()
          {
              HomersAge++;
          }
      }
      int main() {
          ...
          CartoonNameSpace::HomersAge = 39;
          CartoonNameSpace::incrementHomersAge();
          cout << CartoonNameSpace::HomersAge << endl;
          ...
      }
  

new (C++ only)

• Used to allocate a new block of memory for the given type from the heap, and return a pointer to that block of memory. Allocating arrays can be done by providing the size of the array in square brackets.
  

  pointer = new type;
  pointer = new type( initializer );
  pointer = new type[size];

  • pointer is a pointer to the type that you want to allocate the memory for
  • type is the type of the item that is to be stored in the memory that is allocated
  • initializer is the optional information for the constructor
  • size is the size of the array to create

operator (C++ only)

• Used to specify that you are overloading an operator.
  

     return-type class-name::operator#(parameter-list)
      {
          ...
      }
  

  • return-type is the return type for the function
  • class-name is the name of the class that the operator is a part of. If it is not part of a class, this can be left out along with the ‘::‘.
  • # is the operator that is to be overloaded, such as ‘++’. You cannot overload the #, ##, ., :, .*, or ? tokens.
  • parameter-list is the list of parameters that the operator will take. For unary operators, parameter-list should be empty, and for binary operators, parameter-list should contain the operand on the right side of the operator (the operand on the left side is passed as this).
• There are special conventions for some operators, such as the unary ++ and — operators.
  • The unary ++ operator has both prefix (++object and postfix (object++) versions.

  •    return-type class-name::operator++()
        {
            ...
        }
    

    overloads the prefix version (the value returned is the value of the object after it is incremented, so this is also known as the pre-increment version because the increment takes place before the value is returned). There is no parameter specified because ++ is a unary operator.

  •    return-type class-name::operator++( int )
        {
            ...
        }
    

    overloads the postfix version (the value returned is the value of the object before it is incremented, so this is also known as the post-increment version because the increment takes place after the value is returned). The parameter int is not really a parameter (++ is still a unary operator) but is there soley to differentiate the prefix and postfix versions.

private (C++ only)

• Used within a class declaration to specify features of that class that can only be accessed by itself and its friends.
  

  class Date
  {
  public:
      void display();
  
  private:
      int day;
      int month;
      int year;
  }

• Used to inherit a base class privately, which causes all public and protected members of the base class to become private members of the derived class.
  

  class AlarmClock : private Clock
  {
  public:
      void display();
  
  }

protected (C++ only)

• Used within a class declaration to specify features of that class that are private to its own class, but can be inherited by a derived class.
  

  class Date
  {
  public:
      void display();
  protected:
      int day;
      int month;
      int year;
  }

• Used to inherit a base class, which causes all public and protected members of the base class to become protected members of the derived class.
  

  class AlarmClock : protected Clock
  {
  public:
      void display()
  }

public (C++ only)

• Used within a class declaration to specify features of that class that are accessable to everyone.
  

  class Date
  {
  public:
      void display();
  protected:
      int day;
      int month;
      int year;
  }

• Used to inherit a base class publically, which causes all public and protected members of the base class to become public and protected members of the derived class.
  

  class AlarmClock : public Clock
  {
  public:
      void display()
  }

register

• Used to reccommend that a varibale be placed into a processor register so that it is optimized for speed but the compiler is not obliged to do so. This keyword is rarely used anymore since compilers have become better than programmers at optimizing code.

reinterpret_cast (C++ only), seldom used

• Used to change one data type in a non-portable way. It is normally used to cast between incompatible pointer types.
  

  reinterpret_cast<target_type> (object);

return

• Used to cause the execution to jump from the current function back to the one that called it. An optional value can be returned but the function must specify the type that it will return.
  

  return;
  return 5;

short

• Used as a data type modifier for the int type to indicate that there may be less bytes then the type has available. This variable type is normally 16or 32bits (2 or 4bytes) long.
  

  short int i = 5;

signed

• Used to specify that the number type provided could potentially be negative, so it must be stored in a different format. This is the default representation that is chosen by most compilers if either signed or unsigned is not specified.
  

  signed int i = -12;

sizeof

• Used to return the size of the object (in bytes) that is passed to it.
  

  int i = 5;
  int size = sizeof( i );

static

• Used outside any function or class as a qualifier to a variable declaration makes the scope of the variable the file in which the variable is declared, and the extent is permanent (i.e., it is in the static segment).
  

  static int i;

• Used inside a function as a qualifier to a variable declaration makes the scope of the variable the function in which the variable is declared, and the extent is permanent (i.e., it is in the static segment).
  

  void foo()
  {
      static int i;
  }

• Used inside a class as a qualifier to a variable declaration makes the scope of the variable the class in which the variable is declared, and the extent is permanent (i.e., it is in the static segment).
  

  class bar
  {
      static int i;
  }

• Used outside any class as a qualifier to a function declaration makes the scope of the function the file in which the function is declared. As with all functions, the instructions for the function are in the code segment.
  

  static void foo()
  {
  }

• Used inside a class as a qualifier to a function (method) declaration makes the scope of the function the class in which the function is declared (as with all methods), and the instructions for the method are in the code segment (as for all functions). What is different is that a static method is invoked without requiring an object, using the qualifier syntax class::staticMethod( parameters ), although it can also be invoked on an object in the class in the usual way. Because no object is associated with a static method, only static member variables and other static member functions can be invoked by a static method.
  

  class bar
  {
      static void foo();
  }

  Note: A method in a class cannot be both “static” and “virtual”. The reason for this is that virtual functions have to know the object to which they apply (because of polymorphism) but static methods are not applied to an object.

static_cast (C++ only, seldom used)

• Used for a normal conversion between types. No runtime checking is performed.
  

  static_cast<target_type> (object);

struct

• Used to create a structure like a class, but the members are public by default instead of private. In C, structs can only contain data, cannot have inheritance and cannot have data with different visibilities.
  

  struct struct-name : inheritance-list
  {
          public-members-list;
      protected:
          protected-members-list;
      private:
          private-members-list;
  } object-list;

  • struct-name is the name of the struct that is being created.
  • inheritance-list is the optional list of structs inherited by the new struct.
  • public-members-list is the list of public members of the struct.
  • protected-members-list is the list of protected members of the struct.
  • private-members-list is the list of private members of the struct.
  • object-list is an optional list used to immediately instantiate 1 or more instances of the struct.

  struct Date
  {
      int day;
      int month;
      int year;
  }

switch

• Used to test an expression of an integer value against many constant integer values and is commonly used to replace large if()…else if()… statements. Break statements are required between each case statement, otherwise execution will “fall-through” to the next case statement. The default case is optional. If provided, it will match any case not explicitly covered by the preceding cases in the switch statement.
  

  char keystroke = getch();
  switch( keystroke )
  {
      case 'a':
      case 'b':
      case 'c':
      case 'd':
          KeyABCDPressed();
          break;
      case 'e':
          KeyEPressed();
          break;
      default:
          UnknownKeyPressed();
          break;
  }
  

template (C++ only)

• Used to create generic functions and can operate on data without knowing the nature of that data. They accomplish this by using a placeholder data-type for which many other data types can be substituted.
  

  template void genericSwap( X &a, X &b )
  {
      X tmp;
  
      tmp = a;
      a = b;
      b = tmp;
  }
  

this (C++ only)

• Used as a pointer to the current object. All member functions of a class have this pointer.
  

  this.print();

throw (C++ only)

• Used together with try and catch statements to create an exception handling system. Throw is used to generate an exception.
  

  try
  {
      cout << "Before throwing exception"<< endl;
      throw 42;
      cout << "Shouldn't ever see this"<< endl;
  }
  catch( int error )
  {
      cout << "Error: caught exception " << error << endl;
  }
  

true (C++ only)

• Used to represent the Boolean value true.
  

  bool b = true;

try (C++ only)

• Used to attempt to execute exception-generating code.
  

  try
  {
      cout << "Before throwing exception" << endl;
      throw 42;
      cout << "Shouldn't ever see this" << endl;
  }
  catch( int error )
  {
      cout << "Error: caught exception " << error << endl;
  }

typedef

• Used to create a new type from an existing type.
  

  typedef int seconds;

typeid (C++ only, seldom used)

• Used to get a reference to a type_info object that describes the object it was passed.
  

  typeid(object);

typename (C++ only)

• Used to describe an undefined type or in place of the class keyword in a template declaration.

union

Used to create multiple data fields that will occupy the same memory location.

union Data
{
    int i;
    char c;
};

unsigned

• Used to specify that the int or char provided can only be posative and can therefore contain a larger number since there is no need to worry about representation of negative numbers.
  

  signed int i = -12;

using (C++ only)

• Used to import a namespace into the current scope.
  

  using namespace std;

virtual (C++ only)

• Used to create virtual functions that can be overridden by derived functions.
  • A virtual function indicates that a function can be overridden in a subclass, and that the overridden function will actually be used.
  • When a base object pointer points to a derived object that contains a virual function, the decision about which version of that function to call is based on the type of object pointed to by the pointer, and this process happens at runtime.
  • A base object can point to different derived objects and have different versions of the virual function run.

  virtual void print();

• Used to create a pure virtual function which is a virtual function that must be overriden by some derived class.
  

  virtual void print() = 0;

• Note: A method in a class cannot be both “virtual” and “static”.

void

• Used to denote functions that return no value.
  

  void print()
  {
      cout << "printn";
  }
  

• Used to create generic variables which can point to any type of data.
  

  void *p = 5;
  

• Used to declare an empty parameter list.
  

  void print( void )
  {
      cout << "printn";
  }

volatile

• Used to inform the compiler that the variables value can change in unexpected ways (i.e. through an interrupt), which could conflict with optimizations that the compiler might perform, so therefore the compiler will not optimize these variables.
  

  volatile Date d;

wchar_t

• Used to declare a wide character variable. This variable type is normally 16 bits (2 bytes) long.
  

  wchar_t c = ‘c’;

while

• Used as a looping construct that will evaluate a list of statements as long as the condition is true. Note: if the condition starts off as false, the list of statements will never be executed. (You can use a do loop to guarantee that the list of statements will be executed at least once.)
  

  bool done = false;
  while( !done )
  {
      ProcessData();
      if( StopLooping() )
      {
          done = true;
      }
  }

Copyright (C) 2000-2005, The University of British Columbia