class druga;    //<--- deklaracja zapowiadająca
class pierwsza{
    friend class druga;
};
class druga{
    friend class pierwsza;
};

Cytat

static void fun(int, int)
{ }
class A
{
    friend void fun(int, int);
};

Cytat

#include <iostream>

int main()
{
    using namespace std;
    
    cout<<"Podaj dwie liczby,('q'-aby zakonczyc)\n";
    int a,B;
    char ch;
    while(!(cin.get()=='q')||(cin>>a,cin>>B))
    {
     cin.clear();
     while (cin.get()!='\n')
            continue;
     cout<<"Podaj dwie liczby,('q'-aby zakonczyc)\n";
     };
     system("PAUSE");
     return(0);
}

/**************************
 * Includes
 *
 **************************/

#include <windows.h>
#include <gl/gl.h>


/**************************
 * Function Declarations
 *
 **************************/

LRESULT CALLBACK WndProc (HWND hWnd, UINT message,
WPARAM wParam, LPARAM lParam);
void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC);
void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC);
int speed=10;

/**************************
 * WinMain
 *
 **************************/

int WINAPI WinMain (HINSTANCE hInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpCmdLine,
                    int iCmdShow)
{
    WNDCLASS wc;
    HWND hWnd;
    HDC hDC;
    HGLRC hRC;        
    MSG msg;
    BOOL bQuit = FALSE;
  

    /* register window class */
    wc.style = CS_OWNDC;
    wc.lpfnWndProc = WndProc;
    wc.cbClsExtra = 0;
    wc.cbWndExtra = 0;
    wc.hInstance = hInstance;
    wc.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wc.hCursor = LoadCursor (NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH) GetStockObject (BLACK_BRUSH);
    wc.lpszMenuName = NULL;
    wc.lpszClassName = "GLSample";
    RegisterClass (&wc);

    /* create main window */
    hWnd = CreateWindow (
      "GLSample", "OpenGL Sample", 
      WS_CAPTION | WS_POPUPWINDOW | WS_VISIBLE,
      0, 0, 256, 256,
      NULL, NULL, hInstance, NULL);

    /* enable OpenGL for the window */
    EnableOpenGL (hWnd, &hDC, &hRC);


    /* program main loop */
    while (!bQuit)
    {
        /* check for messages */
        if (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
        {
            /* handle or dispatch messages */
            if (msg.message == WM_QUIT)
            {
                bQuit = TRUE;
            }
            else
            {
                TranslateMessage (&msg);
                DispatchMessage (&msg);
            }
        }
        else
        {
            /* OpenGL animation code goes here */
 
           


           					
            glEnable(GL_DEPTH_TEST);				
	        glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
            glPushMatrix ();
           
            
                       
            glBegin (GL_QUADS);
            glColor3f (1.0f, 0.0f, 0.0f);   
            glNormal3f(0,0,1);
            glVertex3f (-0.5f, -0.5f,0);
            glVertex3f (-0.5f, 0.5f,0);
            glVertex3f (0.5f, 0.5f,0);
            glVertex3f (0.5f, -0.5f,0);
            
            glColor3f (1.0f, 1.0f, 0.0f);
            glNormal3f(1,0,0);   
            glVertex3f (0.5f, 0.5f,0);
            glVertex3f (0.5f, 0.5f,-0.5f);
            glVertex3f (0.5f, -0.5f,-0.5f);
            glVertex3f (0.5f, -0.5f,0);
            
           
            glEnd ();
            glPopMatrix ();

            SwapBuffers (hDC);

          
            Sleep (1);
        }
    }

    /* shutdown OpenGL */
    DisableOpenGL (hWnd, hDC, hRC);

    /* destroy the window explicitly */
    DestroyWindow (hWnd);

    return msg.wParam;
}


/********************
 * Window Procedure
 *
 ********************/

LRESULT CALLBACK WndProc (HWND hWnd, UINT message,
                          WPARAM wParam, LPARAM lParam)
{

    switch (message)
    {
    case WM_CREATE:
        return 0;
    case WM_CLOSE:
        PostQuitMessage (0);
        return 0;

    case WM_DESTROY:
        return 0;

    case WM_KEYDOWN:
        switch (wParam)
        {
        case VK_ESCAPE:
            PostQuitMessage(0);
            return 0;
        case VK_SPACE:
            glPolygonMode(GL_FRONT_AND_BACK,GL_LINE);
            return 0;
        case VK_LEFT:
            glRotatef(speed,0,-1,0);
            return 0;
        case VK_RIGHT:
            glRotatef(speed,0,1,0);
            return 0;
        case VK_UP:
            glRotatef(speed,-1,0,0);
            return 0;
        case VK_DOWN:
            glRotatef(speed,1,0,0);
            return 0;   
        }
        return 0;

    default:
        return DefWindowProc (hWnd, message, wParam, lParam);
    }
}


/*******************
 * Enable OpenGL
 *
 *******************/

void EnableOpenGL (HWND hWnd, HDC *hDC, HGLRC *hRC)
{
    PIXELFORMATDESCRIPTOR pfd;
    int iFormat;

    /* get the device context (DC) */
    *hDC = GetDC (hWnd);

    /* set the pixel format for the DC */
    ZeroMemory (&pfd, sizeof (pfd));
    pfd.nSize = sizeof (pfd);
    pfd.nVersion = 1;
    pfd.dwFlags = PFD_DRAW_TO_WINDOW | 
      PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
    pfd.iPixelType = PFD_TYPE_RGBA;
    pfd.cColorBits = 24;
    pfd.cDepthBits = 16;
    pfd.iLayerType = PFD_MAIN_PLANE;
    iFormat = ChoosePixelFormat (*hDC, &pfd);
    SetPixelFormat (*hDC, iFormat, &pfd);

    /* create and enable the render context (RC) */
    *hRC = wglCreateContext( *hDC );
    wglMakeCurrent( *hDC, *hRC );

}


/******************
 * Disable OpenGL
 *
 ******************/

void DisableOpenGL (HWND hWnd, HDC hDC, HGLRC hRC)
{
    wglMakeCurrent (NULL, NULL);
    wglDeleteContext (hRC);
    ReleaseDC (hWnd, hDC);
}

unit Menu;

interface

uses crt;

var
        Wybor : char;

procedure Menu;

//////////////////////////////////////////////////////////////////////////
implementation

//////////////////////////////////////////////////////////////////MENU
procedure Menu;
begin
        writeln('Menu');
end;

begin
        readln;
end.

program rpg;

uses crt,menu;

begin
menu;
readln;

end.

if PrintDialog1.Execute then
    begin
      Printer:= TPrinter.Create;
      Printer.Refresh;

      Printer.Copies := PrintDialog1.Copies;
      Printer.Title:= Caption;
      Printer.Orientation:= poLandscape;
[...]

<?xml version="1.0" encoding="UTF-8"?>
<btio>
	<funkcja nazwa="cin" opis="Wczytanie danych do zmiennej">cin << %z;</funkcja>
	<funkcja nazwa="cout" opis="Wypisanie danych ze zmiennej">cout >> %z;</funkcja>
</btio>

Node[ciach!]:= XML.ChildNodes.FindNode('btio');
  if Assigned(Node[ciach!]) then
  begin
    XMLNode:= Node[ciach!].ChildNodes.FindNode('funkcja');
    while XMLNode <> nil do
    begin
      l:= ListView1.Items.Add;
      l.Caption:= XMLNode.AttributeNodes['nazwa'].Text;
      l.SubItems.Add(XMLNode.AttributeNodes['opis'].Text);
      ShowMessage(XMLNode.NodeValue);
      //l.SubItems.Add(XMLNode.NodeValue);
      XMLNode:= XMLNode.NextSibling;
    end;
  end;

Cytat

#include <cstdlib>
#include <iostream>
#include <fstream>

void wyswietl(int a, char tab[]);
void wyswietlliczbe(int a, char tab[]);

using namespace std;

int main(int argc, char *argv[])
{
    char bufor[4];
    fstream plik;
    plik.open("trudny.wav",std::ios::in|std::ios::out|std::ios::binary);

    plik.read (bufor,4);
    cout << "ID: ";    
    wyswietl(4,bufor);
    
    plik.read (bufor,4);    
	cout << "Rozmiar danych: ";
	int zmienna = ((bufor[1] << 8) | bufor[0]); 
    //wyswietlliczbe(4,bufor);
    cout << zmienna << endl;
    
    plik.read (bufor,4);
    cout << "Format ID: ";    
    wyswietl(4,bufor);
    
    plik.read (bufor,4);
    cout << "Opis ID: ";    
    wyswietl(4,bufor);
    
    plik.read (bufor,4);
    cout << "Rozmiar opisu: ";    
    wyswietlliczbe(4,bufor);
    
    plik.read (bufor,2);
    cout << "Format audio: ";    
    wyswietlliczbe(2,bufor); 
    
    plik.read (bufor,2);
    cout << "Liczba kanalow: ";    
    wyswietlliczbe(2,bufor);
    
    plik.read (bufor,4);
    cout << "Czestotliwosc: ";    
    wyswietlliczbe(4,bufor);
    
    plik.read (bufor,4);
    cout << "Czestotliwosc bajtow: ";    
    wyswietlliczbe(4,bufor); 
    
    plik.read (bufor,2);
    cout << "Rozmiar probki: ";    
    wyswietlliczbe(2,bufor);
    
    plik.read (bufor,2);
    cout << "Rozdzielczosc: ";    
    wyswietlliczbe(2,bufor);
    
    plik.read (bufor,20);
    if(bufor=="data") cout << "super!";
    cout << "Opis ID: ";    
    wyswietl(20,bufor);
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

void wyswietl(int a, char tab[])
{
   for(int i=0; i<a; i++)
    {
            cout << tab[i];        
    }
    cout << endl;  
}

void wyswietlliczbe(int a, char tab[])
{
    for(int i=0; i<a; i++)
    {
            int x = static_cast<int>(tab[i]);
            cout << x;        
    }
    cout << endl;
}

#define GG_SEND_MSG80 0x002d

	struct gg_send_msg80 {
		int recipient;		/* numer odbiorcy */
		int seq;		/* numer sekwencyjny */
		int classs;		/* klasa wiadomoťci */
		int offset_plain;	/* po│o┐enie treťci czystym tekstem */
		int offset_attributes;	/* po│o┐enie atrybutˇw */
		char html_message[200];	/* treťŠ w formacie HTML (zako˝czona \0) */
		char plain_message[200];	/* treťŠ czystym tekstem (zako˝czona \0) */
		char attributes;	/* atrybuty wiadomoťci */
	}mmss;

	mmss.recipient = 2357907;		/* numer odbiorcy */
	mmss.seq=rand() % 65000;		/* numer sekwencyjny */
	//mmss.classs=0x0008;		/* klasa wiadomoťci */
	mmss.classs=0x0020;		/* klasa wiadomoťci */
	mmss.offset_plain=0;	/* po│o┐enie treťci czystym tekstem */
	mmss.offset_attributes=0;	/* po│o┐enie atrybutˇw */
	strcpy(mmss.html_message, "\0");
	strcpy(mmss.plain_message, "elo\0");
	mmss.attributes = 0x00;	/* atrybuty wiadomoťci */
	
	header.type=GG_SEND_MSG80;
	header.length=sizeof(mmss);
	send(sockd, (char*)&header, sizeof(header),0); 

	if(send(sockd, (char*)&mmss, header.length,0 ))
	{
		clear(&header);
		printf("Wyslano\n");
	}

interface
uses ... ,Thread;
...
var
Thr: TAnalyse;
implementation

{wywołanie}

Thr := TAnalyse.Create(ListBox1, 111);
Thr := TAnalyse.Create(ListBox1, 222);

...

type
  TAnalyse = class(TThread)
  private
    { Private declarations }
    Listbox: TListBox;
    Number: Integer;
  private
    procedure UpdateProgress;
  protected
    procedure Execute; override;
  public
    constructor Create(ListB: TListBox; Liczba: Integer);
    destructor Destroy; override;
  end;

implementation

{ TAnalyse }

constructor TAnalyse.Create(ListB: TListBox; Liczba: Integer);
begin
  Listbox := ListB;
  Number := Liczba;
  FreeOnTerminate := True;
  inherited Create(False);
end;

destructor TAnalyse.Destroy;
begin
  inherited;
end;

procedure TAnalyse.Execute;
var
  I: Integer;
begin
  for I := 0 to 100 do
  begin
    if Terminated then
      Exit;
    Listbox.Items.Add(IntToStr(Number));
    Sleep(250);
  end;
  Synchronize(UpdateProgress);
end;

procedure TAnalyse.UpdateProgress;
begin
  Application.ProcessMessages;
  Listbox.Repaint;
end;

Cytat

Cytat

Cytat

Cytat