Testowałem funkcje graficzne w Visual C++ 2008 i przy okazji w pamięci dokonałem przekształceń symetrycznych linii i figur. Rezultatem działania jest taka kolorystyczna kompozycja kalejdoskopowa:

  

Jeśli się komuś przyda to kod do takiej zabawy:

private: System::Void button1_Click(System::Object^  sender, System::EventArgs^  e) {
Graphics^ graf=panel1->CreateGraphics();
SolidBrush^ pedzel1=gcnew SolidBrush(System::Drawing::Color::DarkViolet);
SolidBrush^ pedzel2=gcnew SolidBrush(System::Drawing::Color::Orange);
SolidBrush^ pedzel3=gcnew SolidBrush(System::Drawing::Color::DarkBlue);
SolidBrush^ pedzel4=gcnew SolidBrush(System::Drawing::Color::SkyBlue);
SolidBrush^ pedzel5=gcnew SolidBrush(System::Drawing::Color::Chocolate);
Pen^ pen1=gcnew Pen(System::Drawing::Color::Green);
Pen^ pen2=gcnew Pen(System::Drawing::Color::Red);
Pen^ pen3=gcnew Pen(System::Drawing::Color::Blue);
Pen^ pen4=gcnew Pen(System::Drawing::Color::Brown);
Pen^ pen5=gcnew Pen(System::Drawing::Color::Black);
Pen^ pen6=gcnew Pen(System::Drawing::Color::DarkKhaki);
Pen^ pen7=gcnew Pen(System::Drawing::Color::Chartreuse);
System::Drawing::Font^ font1=gcnew
System::Drawing::Font(System::Drawing::FontFamily::GenericSansSerif,10,FontStyle::Underline);
int srodek_x,srodek_y,dl_x,dl_y,margines;
srodek_x=panel1->Width/2;
srodek_y=panel1->Height/2;
dl_x=panel1->Width;
dl_y=panel1->Height;
margines=5;
pen1->StartCap=System::Drawing::Drawing2D::LineCap::RoundAnchor;
pen1->EndCap=System::Drawing::Drawing2D::LineCap::ArrowAnchor;
pen1->Width=5;
graf->DrawLine(pen1,margines,dl_y-margines,dl_x-margines,margines);
graf->DrawLine(pen1,dl_x-margines,dl_y-margines,margines,margines);
pen2->DashStyle=System::Drawing::Drawing2D::DashStyle::Dot;
pen2->Width=3;
graf->DrawLine(pen2,margines,srodek_y,dl_x-margines,srodek_y);
graf->DrawLine(pen2,srodek_x,margines,srodek_x,dl_y-margines);
pen3->Width=4;
graf->DrawRectangle(pen3,srodek_x-150,srodek_y-150,300,300);
pen4->Width=4;
graf->DrawEllipse(pen4,srodek_x-100,srodek_y-100,200,200);
pen5->Width=4;
graf->DrawEllipse(pen5,srodek_x-200,srodek_y-200,100,100);
graf->DrawEllipse(pen5,srodek_x+100,srodek_y-200,100,100);
graf->DrawEllipse(pen5,srodek_x-200,srodek_y+100,100,100);
graf->DrawEllipse(pen5,srodek_x+100,srodek_y+100,100,100);
pen6->Width=4;
pen6->DashStyle=System::Drawing::Drawing2D::DashStyle::Dash;
pen6->DashCap=System::Drawing::Drawing2D::DashCap::Triangle;
graf->DrawLine(pen6,margines,srodek_y,srodek_x,margines);
graf->DrawLine(pen6,srodek_x,margines,dl_x-margines,srodek_y);
graf->DrawLine(pen6,dl_x-margines,srodek_y,srodek_x,dl_y-margines);
graf->DrawLine(pen6,srodek_x,dl_y-margines,margines,srodek_y);
pen7->Width=3;
graf->DrawRectangle(pen7,srodek_x-40,srodek_y-40,80,80);
graf->FillRectangle(pedzel1,margines+20,margines+20,75,75);
graf->FillRectangle(pedzel1,dl_x-(margines+20+75),margines+20,75,75);
graf->FillRectangle(pedzel1,margines+20,dl_y-(margines+20+75),75,75);
graf->FillRectangle(pedzel1,dl_x-(margines+20+75),dl_y-(margines+20+75),75,75);
graf->FillRectangle(pedzel2,srodek_x-(150+25),srodek_y-25,50,50);
graf->FillRectangle(pedzel2,srodek_x+(150-25),srodek_y-25,50,50);
graf->FillRectangle(pedzel2,srodek_x-25,srodek_y-(150+25),50,50);
graf->FillRectangle(pedzel2,srodek_x-25,srodek_y+(150-25),50,50);
graf->FillEllipse(pedzel3,srodek_x-25,srodek_y-25,50,50);
graf->FillEllipse(pedzel4,srodek_x-15,margines+55,30,30);
graf->FillEllipse(pedzel4,srodek_x-15,dl_y-(margines+85),30,30);
graf->FillEllipse(pedzel4,margines+55,srodek_y-15,30,30);
graf->FillEllipse(pedzel4,dl_x-(margines+85),srodek_y-15,30,30);
graf->DrawString("Graph of Functions in Visual C++",font1,pedzel5,srodek_x+15,margines);
 

 


}

Klasa służąca do badania występowania, prawa do czytania i zapisywania pliku z konstruktora.

class Dostep_do_pliku
{
private:
char *nazwa_pliku;
bool czy_wystepuje(int x)
{
if(x==0)
  return true;
else
  return false;
}
 
public:
Dostep_do_pliku(char *plik)
{
nazwa_pliku=plik;
     } 
void Czy_istnieje()
{
if(czy_wystepuje(access(nazwa_pliku,F_OK)))
 cout<<"plik - "<<nazwa_pliku<<" istnieje"<<endl;
else
{
if(errno==ENOENT)
 cout<<"Plik "<<nazwa_pliku<<" nie istnieje"<<endl;
 else
   if(errno==EACCES)
     cout<<"Plik "<<nazwa_pliku<<" nie jest dostepny"<<endl;
}
 
}
void Czy_do_odczytu()
{
if(czy_wystepuje(access(nazwa_pliku,R_OK)))
 cout<<"plik - "<<nazwa_pliku<<" mozna czytac"<<endl; 
 else
 cout<<"plik - "<<nazwa_pliku<<" nie mozna czytac"<<endl;
}
void Czy_do_zapisu()
{
if(czy_wystepuje(access(nazwa_pliku,W_OK)))
 cout<<"plik - "<<nazwa_pliku<<" mozna zapisywac"<<endl;
else
 if(errno==EACCES)
  cout<<"plik - "<<nazwa_pliku<< "nie mozna zapisac (brak dostepu)"<<endl;
 else 
   if(errno==EROFS)
  cout<<" plik - "<<nazwa_pliku<<" nie mozna zapisac (tylko do odczytu)"<<endl;
}
 
};

Prosta klasa kopiująca plik do pliku z wykorzystaniem - sendfile.

class COPY
{
private:
int zrodlowy,docelowy;
struct stat bufor;
off_t oft;
public:
COPY(char *zrodlo, char *docel)
{
oft=0;
zrodlowy=open(zrodlo,O_RDONLY);
fstat(zrodlowy,&bufor);
docelowy=open(docel,O_WRONLY | O_CREAT,bufor.st_mode);

}
void Send()
{
sendfile(docelowy,zrodlowy,&oft,bufor.st_size);
}
~COPY()
{
close(zrodlowy);
close(docelowy);
}
};

Serwetka z cykloid, to miła dla oka forma graficzna powstała przez przetwarzanie wzoru matematycznego w pętli - for. Program znalazłem w książce - "C++ Builder. 20 efekektownych programów" - Andrzej Stasiewicza. Jako, że kiedyś częściej chłonąłem produkt Borlanda/Embarcadero, a teraz przesiadłem się na Visual C++, to napisałem kod w środowisku Visual C++ EE 2008. Wystarczyło zrobić kosmetyczne zmiany, wprowadzić zmienne niezbędne do przetwarzania grafiki i niby ruszyło, jednakże nie przeskoczyłem Bulderowej funkcji - RGB, w odpowiedniku MS - FromArgb, gdzie użyłem losowych zmiennych - r,g,b z zakresu -0-255 w postaci jednej funkcji:

int Losowa()
{
int x;
x=rand()%256;
return x;
}
private: System::Void Form1_Load(System::Object^  sender, System::EventArgs^  e) {
srand(time(NULL));
}
private: System::Void Form1_Paint(System::Object^  sender, System::Windows::Forms::PaintEventArgs^  e) {

Graphics^ g1=this->CreateGraphics();
System::Drawing::Color kolor;
int x1=Form1::Width/2,y1=Form1::Height/2;
double OMEGA1=1.,il_obieg=1.;
double R1=Form1::Width/2.,R2=Form1::Width/4.;
double t,max_t,x2,y2,x3,y3,x4,y4;
double M_PI=3.14159265359;
max_t=2*M_PI*il_obieg/OMEGA1;
for(t=0;t<max_t;t+=0.03)
{
x2=x1+(R1-R2)*cos(OMEGA1*t);
y2=y1+(R1-R2)*sin(OMEGA1*t);
x3=x2+R2*cos(-OMEGA1*(R1-R2)/R2*t);
y3=y2+R2*sin(-OMEGA1*(R1-R2)/R2*t);
x4=x2-R2*cos(-OMEGA1*(R1-R2)/R2*t);
y4=y2-R2*sin(-OMEGA1*(R1-R2)/R2*t);
kolor=System::Drawing::Color::FromArgb(Losowa(),Losowa(),Losowa());
Pen^ pioro=gcnew Pen(kolor);
g1->DrawLine(pioro,int(x3),int(y3),int(x4),int(y4));
}
}
};
}

"Problem Josephusa" rozwiązany za pomocą użycia struktury i klasy.

struct lista
{
int x;
lista *nastepna;
lista(int a,lista *nastepna2)
{
x=a;
nastepna=nastepna2;

}
   
};
typedef lista *testowa;

class Cykliczna
{
private:
int a,b;
public:
Cykliczna(int x,int y)
{
a=x;
b=y;
int i;
testowa nastepna2=new lista(1,0);
nastepna2->nastepna=nastepna2;
testowa nastepna3=nastepna2;
for(i=2;i<=x;i++)
nastepna3=(nastepna3->nastepna=new lista(i,nastepna2));
while(nastepna3!=nastepna3->nastepna)
{
for(i=1;i<y;i++)
nastepna3=nastepna3->nastepna;
nastepna3->nastepna=nastepna3->nastepna->nastepna;
}

cout<<nastepna3->x<<endl;
}

};

Gry liczbowe Lotto, które są zarówno szansą na polepszenie materialnego bytu,jak i hazardowym złudzeniem (zakładając iluzoryczne szansę wygrania głównej wygranej), to również doskonałe ćwiczenie na operowaniu na tablicach i poznaniu funkcji random.

#include <iostream>
#include <stdlib.h>
#include <unistd.h>
using namespace std;
void Sortuj(int *tabela, int ile)
{
int i,j,temp;
for(i=1;i<ile;i++)
{
j=i;
temp=tabela[j];
while((j>0) && (tabela[j-1]>temp))
{
tabela[j]=tabela[j-1];
j--;

}
tabela[j]=temp;
}

}
class Gry_liczbowe
{
private:
int *tab,ile;
public:
Gry_liczbowe(int x, int y)
{
int i,j,liczba;
tab=new int[x];
ile=y;
int *zast=new int[x];
for(i=0;i<x;i++)
zast[i]=0;
j=0;
do
{
do
{
 liczba=rand()%x;
 
    }while(zast[liczba]!=0);
    zast[liczba]=1;
    tab[j]=liczba+1;
    ++j;
   }while(j<y);
  Sortuj(tab,ile);
  for(i=0;i<y;i++)
  {
  cout<<tab[i]<<"   ";
  }
  cout<<endl;
  
   
delete zast;

}
~Gry_liczbowe()
{
delete tab;
}
};

int main(int argc, char** argv)
{
srand(time(NULL));
Gry_liczbowe Multi_Multi(80,20);
Gry_liczbowe Lotto(49,6);
Gry_liczbowe Mini_Lotto(42,5);
Gry_liczbowe Kaskada(24,12);

return 0;
}

Sortowanie bąbelkowe, wałkowane dawniej w edukacji przy okazji nauki programowania wTurbo Pascalu. Tutaj wersja C/C++.

void sortowanie_babelkowe(int *tablica, int ilosc)
{
int i,j,tymczasowa;
for(i=0;i<ilosc;i++)
{
for(j=ilosc-1;j<=i;j--)
if(tablica[j]<tablica[j-1])
{
tymczasowa=tablica[j-1];
tablica[j-1]=tablica[j];
tablica[j]=tymczasowa;
}
}

}

Funkcja odwracająca tekst, operująca na tablicach char.

void odwrotnosc(char *wyraz)
{
int dl,i;
dl=strlen(wyraz);
char *odwrotny=new char[dl+1];
for(i=0;i<dl+1;i++)
{
odwrotny[i]=wyraz[dl-1-i];
}
cout<<"Odwrotny tekst od -"<<wyraz<<" jest "<<odwrotny<<endl;
delete odwrotny;
}

Silnia przedstawiona jako klasa:

class Silnia
{
private:
int iloczyn;
public:
Silnia(int liczba)
{
int i;
iloczyn=1;
for(i=1;i<liczba+1;i++)
iloczyn*=i;
}
int Wynik()
{
return iloczyn;
}
};

Liczby doskonała to liczba, która równa jest sumie wszystkich swoich dzielników mniejszych od niej samej.
bool czy_liczbaDoskonala(int liczba)
{
int i,suma;
suma=0;
for(i=1;i<liczba;i++)
{
if(liczba%i==0)
suma+=i;
}
if(suma==liczba)
return true;
else
return false;
}

Funkcja sprawdzająca, czy podana liczba należy ro rodziny liczb pierwszych:

bool czy_Pierwsza(int x)
{
int i,suma=0;
for(i=1;i<x+1;i++)
{
if(x%i==0)
++suma;
}
if(suma==2)
return true;
else
return false;
}