Coding Friends

return variable = dynamic_cast<return type>(casting value)
class baseClassDoesWork
{
  protected : 
     int x;
  public : 
     baseClassDoesWork()  { x = 55; };
     virtual int returnX() { cout << "Base class" << endl; return x;}
     void setX(int newXValue) { x = newXValue;}
};
class subBaseClassDoesWork : public baseClassDoesWork
{
  public : 
      subBaseClassDoesWork() : baseClassDoesWork() {};
      int returnX() { cout << "Subclass" << endl; return x;}
};
#include <iostream>

using namespace std;

class baseClassDoesWork
{
  protected : 
     int x;
  public : 
     baseClassDoesWork()  { x = 55; };
     virtual int returnX() { cout << "Base class" << endl; return x;}
     void setX(int newXValue) { x = newXValue;}
};

class subBaseClassDoesWork : public baseClassDoesWork
{
  public : 
      subBaseClassDoesWork() : baseClassDoesWork() {};
      int returnX() { cout << "Subclass" << endl; return x;}
};

int main()
{
    // this one does work because of the virtual method in the base class.
    // but we can create a sub class of the base class first.
    subBaseClassDoesWork *subBase = new subBaseClassDoesWork();
    // convert it to the base class
    baseClassDoesWork *baseDoes = dynamic_cast<baseClassDoesWork*>(subBase);

    // check to see if the casting worked e.g. not equal to 0
    if (baseDoes == 0)
      cout << "Bad casting" << endl;
    else
      cout << baseDoes->returnX() << endl;

    // re-set the value of X
    baseDoes->setX(30);

    // convert it back again to the sub class and things are still great :).
    subBaseClassDoesWork *subBase2 = dynamic_cast<subBaseClassDoesWork*>(baseDoes);
    if (subBase2 == 0)
      cout << "Bad casting" << endl;
    else
      cout << subBase2->returnX() << endl;

    return 0;
}
Subclass
55
Subclass
30
#include <iostream>

using namespace std;

 class baseClassNotWork
 {
   protected : 
      int x;
   public : 
      baseClassNotWork()  { x = 0; };
      int returnX() { return x;}
 };

 class subBaseClassNotWork : public baseClassNotWork
 {
   public : 
       subBaseClassNotWork() : baseClassNotWork() {};
       int returnX() { return x;}
 };

int main()
{
     baseClassNotWork *baseNot = new baseClassNotWork();
     //error: cannot dynamic_cast ‘baseNot’ (of type ‘class baseClassNotWork*’) to type ‘class subBaseClassNotWork*’ (source type is not polymorphic)
     subBaseClassNotWork *subBaseNot = dynamic_cast<subBaseClassNotWork*>(baseNot);
    return 0;
}
returnvalue = static_cast<returntype>(value to cast)
     int pie = 3;
     double fl = static_cast<double>(pie);
   double fl = (double)pie;
returnvalue = const_cast<return type>(casting value)
#include <iostream>

using namespace std;

int main()
{
  const int pies = 3;
  int &newPies = const_cast<int&>(pies);
  cout << "pies = " << pies << endl;
  newPies += 2;
  cout << "new pies = " << newPies << endl;

 // where as you cannot alter the old pies value .. 
 // pies+=2;///error !!
  return 0;
}
pies = 3
new pies = 5
double pi = 3.14;
int piInt = (int)pi;
returnvalue = reinterpret_cast<return type*>(casting value);
#include <iostream>

int main()
{
  int *aInt = new int(10);
  cout << "A value = " << *aInt << endl;

  void *bVoid = reinterpret_cast<void*>(aInt);
  int *aBack = reinterpret_cast<int*>(bVoid);

  cout << "COME BACK TO ME !! A value again = " << *aBack << endl;
}
A value = 10
COME BACK TO ME !! A value again = 10
#include <iostream>

using namespace std;

class classA
{
  public:
    int valueX;
    int valueY;

    classA() { valueX = 0; valueY = 0;}

};

int main()
{
  classA *a = new classA();
  a->valueX = 10;
  a->valueY = 30;
  cout << "Value of X = " << a->valueX << " Value of Y = "  << a->valueY << endl;

  void *aClassVoid = reinterpret_cast<void*>(a);

  a = reinterpret_cast<classA*>(aClassVoid);

  cout << "COME BACK To me !! Value of X = " << a->valueX << " Value of Y = "  << a->valueY << endl;

  cout << "Value of X = " << a->valueX << " Value of Y = "  << a->valueY << endl;
  aClassVoid = reinterpret_cast<void*>(a);
  // but if you alter the values within a variable once you have done the first cast.
  cout << "After the first cast .. Value of X = " << a->valueX << " Value of Y = "  << a->valueY << endl;
  a->valueX = 0;
  cout << "After settings the value to 0 .. Value of X = " << a->valueX << " Value of Y = "  << a->valueY << endl;
  //and try again with the casting with the aClassVoid
  classA *AP = reinterpret_cast<classA*>(aClassVoid);

  cout << "COME BACK To me !! Value of X = " << AP->valueX << " Value of Y = "  << AP->valueY << endl;

  cout << "The last reinterpret_cast leaves the value as 0 for valueX because it is still only pointing to the same place as 'a'" << endl;

   return 0;
}
Value of X = 10 Value of Y = 30
COME BACK To me !! Value of X = 10 Value of Y = 30
Value of X = 10 Value of Y = 30
After the first cast .. Value of X = 10 Value of Y = 30
After settings the value to 0 .. Value of X = 0 Value of Y = 30
COME BACK To me !! Value of X = 0 Value of Y = 30
The last reinterpret_cast leaves the value as 0 for valueX because it is still only pointing to the same place as 'a'
interface Animal
{
  public function printName();
}
class Cat implements Animal
{....
  public function printName()
  {
     echo "Cat class\n";
  }
Fatal error: Class Cat contains 1 abstract method and must therefore be declared abstract or implement the remaining methods (Animal::printName)
<?php
interface Animal
{
  public function printName();
}

class Cat implements Animal
{
      public function printName()
      {
	echo "Cat class\n";
      }
};

class Dog implements Animal 
{
      public function printName()
      {
	echo "Dog class\n";
      }
};

$animals = Array(
    new Cat(), new Dog()
    );

foreach ($animals as $a)
{
    $a->printName();
}

?>
Cat class
Dog class
virtual void printName() = 0;
class Shape
{
     const string name;
      // constructor
     Shape(const string& constructorName) : name(constructorName) {};
}
class Rectangle 
{
      Rectangle(const string& constructorName) : Shape(constructorName) {}
}
poly.cpp:46: error: cannot allocate an object of abstract type ‘Circle’
poly.cpp:21: note:   because the following virtual functions are pure within ‘Circle’:
poly.cpp:11: note:      virtual void Shape::printName()
#include <iostream>
#include <string>

using namespace std;

class Shape 
{
  public:
      Shape(const string& conName) : name(conName) {}; 
      // create a virtual function so that it is implemented in the subclass
      virtual void printName() = 0;

  // protected, so it does not allow direct access, but subclasses can access it.
  protected:
      const string name;
};

// need to be "public Shape" otherwise
// error: ‘Shape’ is an inaccessible base of ‘Circle’
// it will not allow access to the Shape class.
class Circle : public Shape
{
  // you need to specify public for Cat to access Animal string name because that is protected
  public :
      Circle (const string& conName) : Shape(conName) {};
      void printName()
      {
	  cout << name << " class" << endl;
      }
};

class Rectangle: public Shape
{
  // you need to specify public for Dog to access Animal string name because that is protected
  // error: ‘Rectangle::Rectangle(const std::string&)’ is private
  public: 
      Rectangle(const string& conName) : Shape(conName) {};
      void printName()
      {
	  cout << name << " class" << endl;
      }
};

int main()
{
    Shape* shapes[2];
    shapes[0] = new Circle("Cirlce");
    shapes[1] = new Rectangle("Rectangle");

    for (int i =0; i < 2 ; i++)
    {
      shapes[i]->printName();
      // clean up the memory space.
      delete(shapes[i]);
    }
    return 0;
}
Cirlce class
Rectangle class
cd /opt
mkdir flex_sdk_3
cd flex_sdk_3
unzip <place where your free sdk is)
mkdir -p ~/Programming/flex/
<external-library-path>
     <path-element>/opt/flex_sdk_3/frameworks 
<library-path>
     all the <path-element's>/opt/flex_sdk_3/frameworks
<namespaces>
   the <manifest>/opt/flex_sdk_3/frameworks path to the framework directory file.
mkdir -p com/codingfriends/helloworld
// the directory structure of where the class is.
package com.codingfriends.helloworld
{
	public class Greeter
	{
		private var name:String;

		// constructor
		public function Greeter(initialName:String="Ian")
		{
			name = initialName;
		}

		// sayHello returns a String
		public function sayHello():String
		{
			var result:String;
			// if the class private name is present
			if (name!=null && name.length >0)	
			{
				result = "Hello there, "+name+".";
			}
			// should never reach here on a basic run.
			else 
			{
				result="Hello there.";
			}

			return result;
		}
	}
}
public var name:String; // this is a variable named "name" and it is of type String
public function sayHello():String // this is a function named "sayHello" and returns a String type
<?xml version="1.0" encoding="utf-8"?>
<mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" initialize="initApp();">
<mx:Script>
<![CDATA[
import com.codingfriends.helloworld.Greeter;
// the initialize application .. the start
private function initApp():void
{
	// create a new Greeter object with no passing in name
	var myGreeter:Greeter = new Greeter();
	// and say hello world 
	output.text+=myGreeter.sayHello();
	// create a new greeter with the name = genux instead
	var newGreeter:Greeter = new Greeter("genux");
	output.text+=newGreeter.sayHello();
}
]]>
</mx:Script>

<mx:Text id="output" width="100%" textAlign="center"/>
</mx:Application>
PATH=$PATH:/opt/flex_sdk_3/bin
mxmlc -load-config flex-config.xml -source-path=~/Programming/flex/actionscript/ ./com/codingfriends/helloworld/Greeter_mx.mxml -output ./bin/Greeter_mx.swf
53c53
<           <path-element>/opt/flex_sdk_3/frameworks/libs/player/{targetPlayerMajorVersion}/playerglobal.swc</path-element>
---
>           <path-element>libs/player/{targetPlayerMajorVersion}/playerglobal.swc</path-element>
70c70
<          <path-element>/opt/flex_sdk_3/frameworks/libs</path-element>
---
>          <path-element>libs</path-element>
72,74c72,74
<          <path-element>/opt/flex_sdk_3/frameworks/libs/player</path-element>
<          <path-element>/opt/flex_sdk_3/frameworks/libs/player/{targetPlayerMajorVersion}</path-element>
<            <path-element>/opt/flex_sdk_3/frameworks/locale/{locale}</path-element>
---
>          <path-element>libs/player</path-element>
>          <path-element>libs/player/{targetPlayerMajorVersion}</path-element>
>            <path-element>locale/{locale}</path-element>
82c82
<             <manifest>/opt/flex_sdk_3/frameworks/mxml-manifest.xml</manifest>
---
>             <manifest>mxml-manifest.xml</manifest>
import java.applet.Applet;

// basic class extends the applet
public class HelloWorld extends java.applet.Applet {
import java.awt.Graphics;		// need this for the Graphics part of the paint function
import java.applet.Applet;		// to extend from.

public class HelloWorld extends java.applet.Applet {

    // resize the screen 
    public void init()
    {
	resize(150,25);
    }

    public void start()
    {
    }

    // draw with the Graphics class object a string on the canvas, point 50, 25
    public void paint(Graphics graphicsObj)
    {
	graphicsObj.drawString("Hello World!", 50,25);
    }

    public void stop()
    {
    }

    public void destroy()
    {
    }
}
javac HelloWord.java
<HTML>
<head>
<title>A hello world</title>
</head>
<body>
Test output of the program
<applet code="HelloWorld.class" width=150 height=25>
</applet>
</body>
</HTML>
<applet code="HelloWorld.class" codebase="/Appletsexamples/"  archive="HelloWorld.jar" width="150" height="25"></applet>
jar cf <tarname> <file(s) name>

jar cf HelloWorld.jar HelloWorld.class
// constant integer value
const int constValue = 3;
// normal value.
int Value = 10;

//pointers can be constants too
const int * pConst = &constValue;
//the pConst is a pointer to a const int value, the value pointed to cannot be altered, but the pConst memory location can to where it is pointing to.
int * const pConst = &Value;
// here the pConst value pointed to can be altered, but the memory location for the pConst for where it is pointing to cannot be altered (always pointing to the same place).
// of course you can have both.
const int * const pConstConst = &constValue;
// here it is a const int value that has a const pointer that is not allow to change.
const int returnValue(const int value1) const;
#include <iostream>

using namespace std;

// there are 3 different places you can put a const (constant)
// restriction on a function definition line.
// const int returnConstInt(const int value1) const
// {
// }
// in order of placement in the function definition line
// 1: cannot alter the returning value
// 2: cannot alter the passing value
// 3: cannot alter the values of "this" as being the class this

class constTest {
  private : 
    int value;
  public:
    constTest() { value = 0;};

    int returnIntConst(int passingValue) const;
};

// cannot alter any value for the class variables e.g. value in this case.
// of course you could do a const_cast.. which takes off the constant (const) type
int constTest::returnIntConst(int passingValue) const
{
    // cannot alter any value inside the function
    // assignment of data-member ‘constTest::value’ in read-only structure
    // value = 3;
    const_cast<int&> (value) = passingValue;	// take off the const type restriction
    return value;
}

int returnInt(const int value1)
{
  // cannot alter the parameter value1
  //error: assignment of read-only parameter ‘value1’
  // value1 = value1+ 2;
  return (value1 + 2);
}

// returning a constant value, which means that you cannot do anything to the 
// returning value, but if you assign that value to another variable you can
const int returnConstInt(int value1)
{
    value1 = value1 + 2;
    return value1;
}

int main()
{
    // cannot alter the return value of the returnConstInt 
    //  increment of read-only location ‘returnConstInt(3)’
    // int constValue = returnConstInt(3)++;
    int constValue = returnConstInt(3);
    // but you can alter the value of returning int from returnConstInt if passed to a variable
    constValue++;
    cout << constValue << endl;

    constTest cTest;
    cout << cTest.returnIntConst(10) << endl;
    return 0;
}
6
10

bin	binary files for boot up e.g. mount e.g.
boot	boot files – kernel images etc.
dev	devices on the computer.
etc	configuration files for the programs
home	home users, e.g. your name /home/ian
lib	libraries
lib32	libraries for the 32bit programs
lib64	/lib (link to the libraries since I am using the 64 linux version)
lost+found
media	media that is going to be mounted (cd-rom’s)
mnt	media that is going to be mounted (Hard drives etc)
opt	opitional programs e.g. things like google chrome, they are normally place in here is not distro specific.
proc	processes that are happening on the computer, all process you can “talk” to
root	root home files.
sbin	sbin, booted up at initial stage of the boot process, things like modprobe for setting up systems items.
sys	system image of devices attached and also file systems that are loadable.
tmp	tempoary files.
usr	user files, e.g. games, libraries, binary files bin games include lib lib32 lib64 local sbin share src it has its own includes, libraries, sbin and bin directories for all of the files within that user directory.
var	variable files, e.g. logs, apache www hosting files.

bin	/Windows /Windows/System32 /Windows/System
boot	boot.ini file that points to what to do.
dev	Does not appear to have something similar on the file system
etc	/Program Data (depending on Windows versions)
home	/Users
lib	/Windows /Windows/System32 /Windows/System /Windows/.Net (for .Net stuff) etc.
lib32
media	Does not appear to have a link to the different mount points but display them on the windows explorer
mnt	Does not appear to have a link to the different mount points but display them on the windows explorer
opt	/Program files/
proc	Does not appear to have a list of running process on the file system, but you can view them with pslist pskill
root	/Documents/Admin user account
sbin	/Windows
sys	Does not appear to have a list of devices attached
tmp	/tmp
usr	/Program files/
var	/Program files/ or where ever you want them.

Coding Friends

dynamic_cast – cpp

Static_cast – cpp

Linux file structure – comparsion with Windows

const_cast – cpp

Reinterpret_cast – cpp

Polymorphism

Polymorphism

Hello World

Java applet – hello world

const – constants in functions

Pages

Categories

Development

Linux

Windows

Archives

Meta