Основы COM-технологий. Артемов М.А. и др. - 13 стр.

UptoLike

ВУЗ: 

ВГУ | Воронеж

Составители: 

Рубрика: 

TComObjectFactory.Create(ComServer, TObjConvert,
Class_ObjConvert, 'ObjConvert', 'Convert', ciSingleIn-
stance, tmSingle);
end.
3. ȼ ɪɚɡɞɟɥɟ ɨɩɢɫɚɧɢɹ ɢɫɩɨɥɶɡɭɟɦɵɯ ɦɨɞɭɥɟɣ ɩɨɫɥɟ Windows, ActiveX
ɢ ComObj ɫɥɟɞɭɟɬ ɞɨɛɚɜɢɬɶ ɟɳɟ ɢ ɦɨɞɭɥɶ ConvertInterface, ɜ ɤɨɬɨɪɨɦ
ɪɟɚɥɢɡɨɜɚɧ ɢɧɬɟɪɮɟɣɫ IConvert.
4. ȼ ɪɚɡɞɟɥɟ ɨɩɢɫɚɧɢɹ ɬɢɩɨɜ ɞɚɧɨ ɧɚɱɚɥɶɧɨɟ ɨɩɢɫɚɧɢɟ ɧɚɲɟɝɨ ɤɨɦɩɨ-
ɧɟɧɬɚ. ɂɫɯɨɞɹ ɢɡ ɷɬɨɝɨ ɨɩɢɫɚɧɢɹ, ɧɚɲ ɤɨɦɩɨɧɟɧɬ ɧɚɫɥɟɞɭɟɬɫɹ ɨɬ
ɤɥɚɫɫɚ TɋomObject, ɢ ɩɨɞɞɟɪɠɢɜɚɟɬ ɢɧɬɟɪɮɟɣɫ IConvert. ȼ ɪɚɡɞɟɥɟ
protected ɧɚɩɢɫɚɧ ɤɨɦɦɟɧɬɚɪɢɣ «Declare IConvert methods here» (ɨɩɢ-
ɲɢɬɟ ɡɞɟɫɶ ɦɟɬɨɞɵ IConvert). ȼ ɷɬɨɦ ɪɚɡɞɟɥɟ ɨɩɢɫɵɜɚɸɬɫɹ ɜɫɟ
ɮɭɧɤɰɢɢ, ɤɨɬɨɪɵɟ ɩɨɞɞɟɪɠɢɜɚɸɬɫɹ ɢɧɬɟɪɮɟɣɫɨɦ:
TObjConvert = class(TComObject, IConvert)
protected
{Declare IConvert methods here}
function Bin (const n: Word; var Str: WideString): Boolean;
stdcall;
function Oct(const n: Word; var Str: WideString): Boolean;
stdcall;
function Hex(const n: Word; var Str: WideString): Boolean;
stdcall;
end;
5. Ɉɫɬɚɟɬɫɹ ɪɟɚɥɢɡɨɜɚɬɶ ɮɭɧɤɰɢɢ ɨɛɴɟɤɬɚ TObjConvert ɜ ɪɚɡɞɟɥɟ
implementation:
implementation
uses ComServ;
{ TObjConvert }
function TObjConvert.Bin(const n: Word; var Str: WideString): Boo-
lean;
var
S: String;
m: Word;
begin
result:=true;
try
S:='';
m:=n;
25
26
repeat
S:=chr(m mod 2+48)+S;
m:=m div 2;
until m=0;
Str:= WideString(S);
except
result:=false;
end;
end;
function TObjConvert.Oct(const n: Word; var Str: WideString): Boo-
lean;
var
S: String;
m: Word;
begin
result:=true;
try
S: ='';
m:=n;
repeat
S:=chr(m mod 8+48)+S;
m:=m div 8;
until m=0;
Str:=WideString (S);
except
result:=false;
end;
end;
function TObjConvert.Hex(const n: Word; var Str: WideString): Boo-
lean;
var
S: String;
m,k: Word;
begin
result:=true;
try
S:='';
m:=n;
repeat
         TComObjectFactory.Create(ComServer, TObjConvert,                     repeat
               Class_ObjConvert, 'ObjConvert', 'Convert', ciSingleIn-             S:=chr(m mod 2+48)+S;
               stance, tmSingle);                                                 m:=m div 2;
  end.                                                                        until m=0;
3. � ������� �������� ������������ ������� ����� Windows, ActiveX             Str:= WideString(S);
   � ComObj ������� �������� ��� � ������ ConvertInterface, � �������       except
   ���������� ��������� IConvert.                                             result:=false;
4. � ������� �������� ����� ���� ��������� �������� ������ �����-           end;
   �����. ������ �� ����� ��������, ��� ��������� ����������� ��         end;
   ������ T�omObject, � ������������ ��������� IConvert. � �������       function TObjConvert.Oct(const n: Word; var Str: WideString): Boo-
   protected ������� ����������� «Declare IConvert methods here» (���-   lean;
   ���� ����� ������ IConvert). � ���� ������� ����������� ���
   �������, ������� �������������� �����������:                          var
    TObjConvert = class(TComObject, IConvert)                                  S: String;
    protected                                                                  m: Word;
       {Declare IConvert methods here}                                   begin
       function Bin (const n: Word; var Str: WideString): Boolean;          result:=true;
       stdcall;                                                             try
       function Oct(const n: Word; var Str: WideString): Boolean;              S: ='';
       stdcall;                                                                m:=n;
       function Hex(const n: Word; var Str: WideString): Boolean;              repeat
       stdcall;                                                                    S:=chr(m mod 8+48)+S;
    end;                                                                           m:=m div 8;
5. �������� ����������� ������� ������� TObjConvert � �������                  until m=0;
   implementation:                                                             Str:=WideString (S);
                                                                            except
    implementation                                                             result:=false;
                                                                            end;
    uses ComServ;                                                        end;
    { TObjConvert }                                                      function TObjConvert.Hex(const n: Word; var Str: WideString): Boo-
    function TObjConvert.Bin(const n: Word; var Str: WideString): Boo-   lean;
    lean;                                                                var
    var                                                                        S: String;
          S: String;                                                           m,k: Word;
          m: Word;                                                       begin
    begin                                                                   result:=true;
       result:=true;                                                        try
       try                                                                     S:='';
          S:='';                                                               m:=n;
          m:=n;                                                                repeat

                                   25                                                                 26

Страницы