Sorry your browser is not supported!

Vector3 operator +(const Vector3 &a) const
{
 (x + a.x, y + a.y, z + a.z); 
}

Vector3 a, b, c;

c = a + 5 * b / 10;

&c = &a + 5 * &b / 10;

class MENUSETUPCLASS{
public:
	GUI_MENU_UTILITY *MG;
	void InitializeTheMenu(GUI_MENU_UTILITY &Menugui);
	void AddMenuItemToGroup(int Group,int Style,char *ID,char *Caption,int lx,int ly,int sx,int sy,int Row,int Col);
}MenuSetup;
..........
..........
	GUI_MENU_UTILITY GUIMenu;
	MenuSetup.InitializeTheMenu(GUIMenu);
...... and then in the InitializeTheMenu()
void MENUSETUPCLASS::InitializeTheMenu(GUI_MENU_UTILITY &Menugui){
	MG=&Menugui;
	MG->InitMenuGUI("..\\Images\\",1,20,100,"");

#include <iostream>
using namespace std; 

int main()
{
	int* PointerVar; 
	int Var = 10; 
	PointerVar = &Var;

	cout<<*PointerVar<<endl; 
	cin.get();
	return 0;
}

#include <iostream>
using namespace std; 

int Add(int& First, int & Second); 
int main()
{ 
	int Var = 10;
	int Var2 = 20; 
	int total; 

	total = Add(Var,Var2);

	cout<<total<<endl; 
	cin.get();
	return 0;
}
int Add(int &First, int &Second)
{
	int Total; 
	Total = First + Second;

	return Total; 
}

#include <iostream>
using namespace std; 

int main()
{
	int * PointerVar;  // 'PointVar' points to the value at the address of an integer value
	int Var = 10;      // Assign the integer 'Var' to the value '10'
	PointerVar = &Var; // Assign the value at the address pointed to by 'PointerVar' to the address of 'Var'

	// the above is equivalent to:
	int var = 10;     // assign the integer 'var' to a value of 10
	int *pVar = &var; // (helps to read this as the compiler would--right side first)
	                  // address of 'var' is assigned to the address pointed to by 'pVar'

	cout<<*PointerVar<<endl; // output the value pointed to by PointerVar
	cin.get();

	return 0;
}

void swap(int &a, int &b)  // the value at the address of a is an integer
{
	int t = a;  // t equals the value of a
	a = y;
	b = t;
	cout << "... swapped values ..." << endl;
}

void fail_swap(int a, int b)
{
	int t = a;
	a = y;
	b = t;
	cout << "... swapped values ... (fail)" << endl;
}

int main()
{
	int x = 5;
	int y = 2;
	cout << "1) x = " << x << ", y= " << y << endl;
	swap(x,y);
	cout << "2) x = " << x << ", y= " << y << endl;
	fail_swap(x,y);
	cout << "3) x = " << x << ", y= " << y << endl;

	return 0;
}
// outputs:
// 1) x = 5, y = 2
// ... swapped values ...
// 2) x = 2, y = 5
// ... swapped values ... (fail)
// 3) x = 2, y = 5

int i = 10;
int *pVal = &i; // as above
int j;
int k = 50;

j = *pVal; // now j equals 10
*pVal = k; // now i equals 50

// pVal points to the value at the address of i. Thus, when you
// assign j to the value pointed to by pVal, you are assigning j
// to the value of i. When you assign the k to the value at the
// address pointed to by pVal, you are assigning i to the value of k.


int i = 20;
int &r = i;
++r; // now i equals 21

// the address of r is assigned to the value of i. Thus, r and i 
// will always have the same value. Incrementing r increments i as 
// well because they have the same address in memory. If the next
// statement was:

r += i; 

// both r and i equal 42. It is equivalent to:

int a = 21;
a += a;

int Var = 10;      // Assign the integer 'Var' to the value '10'

int Var = 10;      // Assign the value '10' to the integer variable 'Var'

int* p = &i; // p holds the address of i
int& p = i;  // p is a reference to i (or p is an alias of i)

& int memberAt(int row, int column)
{
   return m[row][column];
}

memberAt(3,2) = 5;