Visual Basic  vs  C++

’ keeles VB kommentaar rea lõpuni
	
/*  C kommentaar  */
//  keeles C++ kuni rea lõpuni!	
Dim x As Single, n As Integer
Dim rida As String
Dim m(10) As Integer	float  x;  int n;
char  rida[ 41 ];   // NB!  40+1
int  m[ 11 ];       // NB! indeksid 0..10	
Function f( ) As Integer

          k = 1 :  j = 0 
          Do While  k <> 0  
          
                If  k > 7  Then
                     j = j - 1
                Else   
                     j = j + 1
                End If 
          Loop 
          f = j
End Function	int f( void )
{
        k = 1; j = 0;
        while( k != 0 )     // while( k )
        {
               if( k > 7 )                   
                        j --;           // NB! ;
                else  j ++;

         }
         return j;
}	

For  j = 1 To 10 Step 1
      m( j ) = m( j ) + 3
Next j	
for( j = 1; j <= 10;  j++ )
       m[ j ] += 3;

Do
       If k = 3 Exit Do 
       j = k Mod 7
Loop Until  j <> 0;	
do {
          if( k == 3 ) break;
          j = k  %  7; 
} while( j == 0);          //  while( !j );

Failide nimed:  *.CPP

#include  <stdio.h>            		  //  standard  input-output

int  main( void )				  //  põhiprogramm
{
		printf(  “Hello, World! \n” );	  
		return  0;
}

C
	Brian W. Kernighan, Dennis M. Ritchie. The C Programming Language, 1978.
	Viktor Leppikson. Programmeerimine keeles C. Külim, ...

C++
	Bjarne Stroutstrup. The C++ Programming Language, 1986.
	Rein Jürgenson, Teodor Luczkowski. Objektitehnika. C++, Külim, 1995.

Internet

	http://www.tud.ttu.ee/material/kallik/

http://www.cplusplus.com/doc/tutorial/The Cplusplus.com Language Tutorial 	

Konstandid

“See on string”                          
‘a’        			//  see on üks sümbol
‘\n’     			//  \n  on “reavahetus” – ka stringi sees!		       ‘\214’				//  214 == sümboli ASCII 8-ndkood
	
0126				// octal integer – algab nulliga	     	
0x3F    			//  hex integer – algab 0x
567389056L     		// Long decimal integer – lõppeb L

3.14159			// float
123.456789D		// double
2.7e-4				// sama mis  0.00027
Tüübid

char     sümbol  või  sümbolite  massiiv (string);  interpreteeritakse
             kui  täisarvu  -128..127

int	    2-baidine täisarv (ehk short )
long	    4-baidine täisarv

unsigned  midagi    (kus midagi  on kas char, int, short või long) – 
                                 mittenegatiivne täisarv, näit. unsigned char on 
  vahemikus  0..255 

unsigned		sama mis   unsigned int

float    double     		reaalarvud

enum     	loendustüüp

void       	“tüübita” (või ükskõik mis tüüpi) asi

near     long     huge     viitmuutujate (aadressite) erikujud

sizeof( midagi )    midagi-tüüpi muutuja pikkus baitides

Nimelised konstandid

const  PII=3.14159,  NMAX=99,  NL = ‘\n’, MAXMAX = 123456789L;

Lihtmuutujad

char c, d;			// lühikesed täisarvud
				// tavaliselt   sizeof( char ) == 1
int m, n;			// “tavalised” täisarvud
				// tavaliselt   sizeof( int ) == 2
long  x,y;			// pikad täisarvud
				// tavaliselt sizeof( long ) == 4
unsigned  char  u,v;	//  mittenegatiivsed lühikesed täisarvud
unsigned  a, b;		//  mittenegatiivsed tavalised täisarvud
unsigned  long  s, t;	//  mittenegatiivsed pikad täisarvud

float  iks;		// lühike ujukoma arv
double igrek;	// pikk ujukoma arv

int  vektor[ 20 ],  maatriks[ 7 ][ 12 ];   	 //  indeksid alati 0..N-1!

char  s6na[ 9 ];       			 // sümbolite massiiv või string

char  *p;  	  // viitmuutuja mingile char-tüüpi asjale

// puudub Boolean tüüp  
// Avaldis on tõene parajasti siis, kui ta on nullist erinev!

	int k;
	if( k ) ...		// täiesti korrektne!

// saab defineerida andmetüübi kirjelduse lühendi:

typedef  unsigned char uchar;       		 // uchar on uus tüüp
uchar u, v;						//  OK
typedef  int[ Nmax]  vektor;			// nagu ka vektor
vektor oma;						// OK

enum Mast = { RISTI, RUUTU, ARTU, PADA };	       // loendustüüp
Mast laud, kasi;			// laud ja kasi on Mast-tüüpi muutujad
if( laud == PADA ) ... 		// OK
if( kasi > laud ) ...			// OK

// RISTI == 0, RUUTU ==1 jne. 

//  muutuja kirjeldamisel võib talle omistada ka algväärtuse:

int  m = 4,  n = -1;   float  pii = 3.14159;  char c = ‘X’,

double  tt[  ] = { 3.14159,  2.718282,  -1e-7 };
int tabel[ 3 ][ 2 ] ={ { 2, -4 }, { -9, 14 }, { 0, 3 } };

char  tervitus[] = “Hello, World!”;	// see on string

// stringe käsitletakse kui char-tüüpi massiive
// stringi lõputunnuseks on bait, mille väärtuseks on täisarv null ‘\000’
// seega peab stringi kujutava sümbolite massiivi pikkus olema 
// vähemalt 1 võrra suurem kui stringi pikkus

// muutujad tuleb kirjeldada enne nende kasutamist, kuid mitte 
// tingimatta ploki alguses!!!

// viitmuutujate deklareermine:

char *tekst;			//  muutuja tekst väärtuseks on mingi
// char-tüüpi muutuja aadress 
char rida[ ] = “See on rida”;
tekst = & rida[ 3 ];		// massiivi elemendi aadressi leidmine ja omistamine
if( *tekst == ’Z’ ) 		// aadressi järgi väärtuse lugemine ja võrdlus
	*text = ’x’;		// omistamine mällu, millele aadress on muutujas tekst

Relatsioonid 

<        <=        ==       !=        >=         >

Operaatorid

( ) 		funktsiooni väljakutse 
[ ]		massiivi elemendi poole pöördumine
.		eraldaja liitnimes
- >		osutamine viitmuutuja kaudu struktuuri (kirje) osale

!		loogiline eitus NOT
~		bithaaval eitus
-	unaarne miinus
++		auto-inkrement
-- 		auto-dekrement
&		(muutuja) aadressi võtmine
*		viitamine viitmuutuja väärtuse (aadressi) kaudu

(tüüp)		tüübiteisendus, näiteks:
			int n = 13;  float x;
			x = (float) n;

sizeof( midagi )		// midagi pikkus baitides

*       		korrutamine
/		jagamine
%		modulo
+		liitmine
-	lahutamine
<<		nihe bithaaval vasakule (korrutamine 2-ga ?)
<<		andmete saatmine väljundvoogu
>>		nihe bithaaval paremale ( mod 2  ?)
>>		andmete lugemine sisendvoost
&		bithaaval konjuktsioon
^		bithaaval välistav disjunktsioon
|		bithaaval disjunktsioon
&&		konjuktsioon AND
| |		disjunktsioon OR

<avaldis>  ?  <kui tõene>  :  <kui väär>		//  IF-avaldis

new		dünaamilise mälu reserveerimine; näiteks:

				int *p = new int [ 12 ];
				float *q = new float;

delete		dünaamilise mälu vabastamine

delete q;
Omistamine

=     *=    /=     %=    +=    -=     <<=     >>=     &=    ^=     |=

	kus   a = b   tähendab sama, mis  a = a  b

NB!  Omistamised on avaldised, mille väärtuseks on avaldise vasakule poolele omistatud väärtus. Näiteks:

		x = y += z++ ;
		if( m = n – 2 ) ...		// siin ei ole võrdlus!!!

Autoinkrement ja -dekrement

		n++;		//   sama mis  n += 1;  post-autoincrement
		++n;		//   sama mis eelmine; pre-autoincrement

Kuid omistamisavaldise väärtus on post ja pre autoinkremendi puhul erinev:

		int k, m = 3;
		k = m++;		//  m == 4;  k == 3;
		k = ++m;		//  m == 5;  k == 5;

Sama kehtib ka autodekrement - - kohta.

Laused

Iga avaldis (muuhulgas ka omistamisavaldis ja funktsiooni väljakutse) on lause!

{    }			liitlause

goto  L		märgend peab olema kujul   L:  ja võib paikneda suvalises kohas
			sama funktsiooni sees

break			väljumine “lähimast”  while, do, for või switch
lausest

continue		goto „lähima“ korduslause algusesse (tsükli järgmisele
sammule)

return  		väljumine protseduurist 
return avaldis	väljumine funktsioonist koos funktsiooni väärtuse 
			määramisega

IF-lause
IF-ELSE-lause
SWITCH-lause		vrdl. Pascal´i CASE-iga
WHILE-lause		eelkontrolliga korduslause
DO-WHILE-lause		järelkontrolliga korduslause
FOR-lause			eelkontrolliga loenduskorduslause

Funktsioonid

Iga funktsiooni väljakutse on avaldis. Reeglina tuleb enne funktsiooni väljakutset see funktsioon ka defineerida.

Funktsiooni kirjelduse (definitsiooni) üldkuju:

<väärtuse_tüüp>  <funktsiooni_nimi> ( <form_ parameetrite_loetelu> )
{  <laused> }	// funktsiooni keha 

Kui   <väärtuse tüüp> == void    siis nn. protseduur (funktsioon kui avaldis, 
 millel aga puudub väärtus)

<form_ parameetrite_loetelu> on komadega eraldatud lihtmuutujate definitsioonide loetelu. 

Kui   <parameetrite loetelu> == void    siis funktsioonil parameetreid pole.

Näide:
		float jagamine( int k, int j )
		{
			return  k / (float) j;
		}

// ja nüüd kuskil mujal
float x;
		x = jagamine( 2, 3 );		// funktsiooni väljakutse !!!

Formaalste parameetrid edastatakse keeles C alati  väärtuse järgi. 

	void vaheta( int m, int n )		// parameetrite edastamine väärtuse
// järgi
	{
		int abi = m; m = n; n = abi;
		return;	// ei ole kohustuslik!
	}
	.........
	int a = 3, b = -7;
	vaheta( a, b );
	// ei tööta, sest m ja n on küll vahetatud, aga a ja b mitte!

void vahetaC( int *p, int *q )	// klassikaline C – parameetrite aadressite
// edastamine
	{
		int abi = *p; *p = *q; *q = abi;
		return;	
	}
	.........
	int a = 3, b = -7;
	vahetaC( &a, &b );
	// nüüd on a ja b-ga OK!

void vahetaCPP( int &m, int &n )	// CPP: faktiliste parameetrite
// edastamine nime (viite) järgi
	{
		int abi = m; m = n; n = abi;
		return;		
}
	.........
	int a = 3, b = -7;
	vahetaCPP( a, b );	// a ja m, b ja n on paarikaupa sünonüümid!
	//  OK!!!
Kui funktsiooni lokaalse muutuja kirjelduses esineb võtmesõna static, siis sellise muutuja elueaks on kogu programmi eluiga (vrdl. programmi globaalsed muutujad). Näide:

int  proge( void )   // väljastab tema poole pöördumise jrk.nr.
{
		static int mitmes = 0;
		mitmes++;
		cout  <<  mitmes  <<  “. pöördumine\n”;
		return mitmes;
}

NB! Ühelgi C(PP)-funktsioonil ei saa olla alamfunktsioone või –protseduure!

Struktuurid

Kirjetüübi kirjeldamine:

struct  <tüübi_nimi>  {  <väljade_kirjeldused> }

union  <tüübi_nimi>  {  <väljade_kirjeldused> }

Näide:

	struct  Isik				// uus kirjetüüp
	{
		char nimi[ 40 ];
		int kood;
		int vanus;
	}
	
Isik  mina, sina;			// uued Isik-tüüpi muutujad
	mina.kood = 7;
	sina.vanus = 20;
	Isik *keegi;				// viitmuutja
	keegi = & sina;
	if( keegi -> vanus  > 33 ) ...	// OK
	
Kirjeldaja  union  korral on kõigil kirje väljadel ühine mälu!

union  Bit32
{
	long  arv;			//  4-baidine täisarv
	unsigned char bait[ 4 ];  	// massiiv neljast baidist
}

arv ==	bait[3]	bait[2]	bait[1]	bait[0]	

Bit32  pikk;
      	pikk.arv = 0;  		// käsitleme kui pikka täisarvu   
pikk.bait[2] = 0x2A;	// muudame ühe baidi
Bit32  *viit;
      	viit = &pikk;     
viit -> bait[1] = 103;	// muudame veel ühe baidi

NB!  Kirjete jaoks on defineeritud ka omistamistehe!