struct info {    
    int RegCode;
    char FIO[25];
    char Address[255];
    int INN;
    
    bool equals(const info& obj) {
        return ( RegCode == obj.RegCode         && 
                 !strcpy(FIO, obj.FIO)          && 
                 !strcpy(Address, obj.Address)  && 
                 INN == obj.INN 
                ) ;
    }
};

info& operator[](int i) {
        if( i < 0 || i >= size ) {
            std::cerr << "ArrayOutOfBounds" << std::endl;
        } else {
            return *(a[i]);
        }
    }
    
    bool operator==(const info** right) const {
        info* curInfo = 0;
        for(int i = 0; i < counter; ++i) {
            curInfo = a[i];
            if( !curInfo->equals(*(right[i])) ) {
                return false;
            }
        }
    }
    
    // предполагается что массивы одинаковых размеров
    const info** operator=(const info** right) {
        for( int i = 0; i < counter; ++i ) {
            if( a[i] != 0 ) {
                delete a[i];
            }
            
            a[i] = new info();
            a[i]->RegCode = right[i]->RegCode;
            a[i]->INN = right[i]->INN;
            strcpy(a[i]->FIO, right[i]->FIO);
            strcpy(a[i]->Address, right[i]->Address);
        }
        
        return (const info**)a;
    }
    
    void operator!() {
        if(a == 0) {
            return;
        }
        
        for( int i = 0; i < counter; ++i ) {
            if( a[i] != 0 ) {
                delete a[i];
            }
        }
        
        delete []a;
    }

Ах+Ву+С=0

A1/B1 = A2/B2

A1 * A2 + B1 * B2 = 0

text := 'abcdefghi';
Label1.Caption := '';
for i := 1 to length(text) do
  begin
    Label1.Caption := Label1.Caption + text[i];
    for j := 1 to 10 do
      begin
         sleep(10);
         Application.ProcessMessages;
      end;
  end;

//---------------------------------------------------------------------------
 
#pragma hdrstop
 
//---------------------------------------------------------------------------
 
#include <iostream.h>
#include <conio.h>
#include <string.h>
#include <vcl.h>
#include <stdio.h>
#pragma argsused
struct info
{
    int RegCode;
    char FIO[25];
    char name[255];

};
template <class t> 
class array
{
    private:
            int size;
            t** a;
            int counter;
            void SetArray( int );
    public:
        array( int );
        array(array &x);
        ~array();
        void Input(t );
        void Output();
        void OutputByIndex(int);
        void GetSize();
        array operator !();
        array operator =(array );
        void operator [](int );
        bool operator ==(array);
 
};
template <class t>
array<t>::array(int size)
{
    SetArray(size);
}
template <class t>
array<t>::array (array &x)
{
    size=x.size;
    counter = x.counter;
    a = new t*[size];
    for ( int i=0; i < counter; i++)
    {
        a[i]= x.a[i];
    }
}

template <class t>
array<t>::~array()
{
 if (a)
  delete []a;
}
//--------------------------------------------
template <class t>
void array<t>::SetArray(int siz)
{
    a = new t*[siz];
    for(int i = 0; i < siz; i++)
    {
        a[i] = 0;
    }
    size = siz;
    counter = 0;
}
template <class t>
void array<t>::Input(t x)
{
 
    if( counter != size )
    {
            a[ counter ] = new t;
            *a [ counter ] = x;
            counter++;
    }
    else
    {
        cout << "Error. Array is full";
    }
}
template <class t>
void array<t>::Output()
{
    if( counter )
    {
        for( int i = 0; i <counter; i++)
        {
            cout << "SHifr: " << a[ i ]->RegCode << "\n";
            cout << "FIO: " << a[ i ]->FIO << "\n";
            cout << "nazvanie: " << a[ i ]->name<< "\n";
             cout << "\r\n";
         }
    }
    else
    {
        cout << "Error. Array is empty"<<endl;
    }
}
template <class t>
void array<t>::OutputByIndex(int ind)
{
    if( counter )
    {
        if( ind > counter )
            cout << "Error. Index out of range";
        else
        {
                cout << "SHifr: " << a[ ind-1 ]->RegCode << "\n";
                cout << "FIO: " << a[ ind -1]->FIO << "\n";
                cout << "nazvanie " << a[ ind -1]->name << "\n";

                cout << "\r\n"<<endl;
        }
    }
    else
        cout << "Array is empty\n"<<endl;
 
}
template <class t>
void array<t>::GetSize()
{
    cout << counter  << "\n";
}
//----------------------------------------------
 template <class t>
array<t> array<t>::operator =(array<t> x)
{
    counter = x.counter;
    size = x.size;
    a = new t* [size];
    for(int i = 0; i < counter; i++)
    {
       a[i] = x.a[i];
    }
   return *this;
}
 
 template <class t>
void array<t>::operator [](int ind)
{
  OutputByIndex(ind);
}
 
 template <class t>
array<t> array<t>::operator !()
{
    if( counter )
    {
        for( int i = 0; i < counter; i++ )
        {
            delete a[i];
            a[i] = 0;
        }
    }
    counter = 0;
    return *this;
}
     template <class t>
bool array<t>::operator ==(array<t> x)
{
if (x.counter !=counter)
return false;
for (int i=0;i<counter;i++)
if (a[i]!=x.a[i] )
return false;
return true;
}
 
void menu()
{
    cout << "\n Viberite:\n";
    cout << "\n1. vvod ";
    cout << "\n2. vivod ";
    cout << "\n3. ! Clear array.";
    cout << "\n4. = Prisvaivanie." ;
    cout << "\n5. [] vivod po indeksu." ;
    cout << "\n6. == proverka na ravenstvo." ;
}
 
 
int main()
{
int x, ind;
    info temp;
    cout << "Input array size: ";
    cin >> x;
    array<double> obj(x);
    array<double> obj1(x);
    int i;
    while (true)
    {
    menu();
    cin>>i;
    clrscr();
        switch(i)
        {
            case 1:
            cout << "SHifr: ";
            cin >> temp.RegCode;
            cout << "Input FIO: ";
            cin.get();
            cin.getline(temp.FIO, 25);
            cout << "Input nazvanie: ";
            cin.getline(temp.name,255);
            obj.Input(temp);
            break;
            case 2: obj.Output(); break;
 
            case 3: !obj;!obj1; break;
            case 4:
             obj1 = obj;
             obj.Output();
             obj1.Output();
                 break;
             case 5:
            cout << "Input index: ";
            cin >> ind;
            obj[ind];
 
            break;
             case 6:
            if(obj==obj1)
           { cout<<"MHO}|{ECTBA PABHbI"<<endl;
            obj.Output();obj1.Output(); }
            else
           { cout<<"MHO}|{ECTBA HE PABHbI"<<endl;
            obj.Output();obj1.Output();     }
            break;
             case 0: return 0;
            default : cout<<"\nError!\n" ;
        }
    }
}