小弟是delphi初学者,师兄师姐们给我介绍一下object pascal自带的函数好么?

最好能全些..
比如字符串操作的,集合操作之类的,
还有网络用的函数,谢了!

不够再加分!

62 个解决方案

#1

//sysutils.pas
function Languages: TLanguages;
function AllocMem(Size: Cardinal): Pointer;
procedure AddExitProc(Proc: TProcedure);
function NewStr(const S: string): PString; deprecated;
procedure DisposeStr(P: PString); deprecated;
procedure AssignStr(var P: PString; const S: string); deprecated;
procedure AppendStr(var Dest: string; const S: string); deprecated;
function UpperCase(const S: string): string;
function LowerCase(const S: string): string;
function CompareStr(const S1, S2: string): Integer;
function CompareMem(P1, P2: Pointer; Length: Integer): Boolean; assembler;
function CompareText(const S1, S2: string): Integer;
function SameText(const S1, S2: string): Boolean;
function AnsiUpperCase(const S: string): string;
function AnsiLowerCase(const S: string): string;
function AnsiCompareStr(const S1, S2: string): Integer;
function AnsiSameStr(const S1, S2: string): Boolean;
function AnsiCompareText(const S1, S2: string): Integer;
function AnsiSameText(const S1, S2: string): Boolean;
function AnsiStrComp(S1, S2: PChar): Integer;
function AnsiStrIComp(S1, S2: PChar): Integer;
function AnsiStrLComp(S1, S2: PChar; MaxLen: Cardinal): Integer;
function AnsiStrLIComp(S1, S2: PChar; MaxLen: Cardinal): Integer;
function AnsiStrLower(Str: PChar): PChar;
function AnsiStrUpper(Str: PChar): PChar;
function AnsiLastChar(const S: string): PChar;
function AnsiStrLastChar(P: PChar): PChar;
function WideUpperCase(const S: WideString): WideString;
function WideLowerCase(const S: WideString): WideString;
function WideCompareStr(const S1, S2: WideString): Integer;
function WideSameStr(const S1, S2: WideString): Boolean;
function WideCompareText(const S1, S2: WideString): Integer;
function WideSameText(const S1, S2: WideString): Boolean;
function Trim(const S: string): string; overload;
function Trim(const S: WideString): WideString; overload;
function TrimLeft(const S: string): string; overload;
function TrimLeft(const S: WideString): WideString; overload;
function TrimRight(const S: string): string; overload;
function TrimRight(const S: WideString): WideString; overload;
function QuotedStr(const S: string): string;
function AnsiQuotedStr(const S: string; Quote: Char): string;
function AnsiExtractQuotedStr(var Src: PChar; Quote: Char): string;
function AnsiDequotedStr(const S: string; AQuote: Char): string;
function AdjustLineBreaks(const S: string; Style: TTextLineBreakStyle = {$IFDEF LINUX} tlbsLF {$ENDIF} {$IFDEF MSWINDOWS} tlbsCRLF {$ENDIF}): string;
function IsValidIdent(const Ident: string): Boolean;
function IntToStr(Value: Integer): string; overload;
function IntToStr(Value: Int64): string; overload;
function IntToHex(Value: Integer; Digits: Integer): string; overload;
function IntToHex(Value: Int64; Digits: Integer): string; overload;
function StrToInt(const S: string): Integer;
function StrToIntDef(const S: string; Default: Integer): Integer;
function TryStrToInt(const S: string; out Value: Integer): Boolean;
function StrToInt64(const S: string): Int64;
function StrToInt64Def(const S: string; const Default: Int64): Int64;
function TryStrToInt64(const S: string; out Value: Int64): Boolean;
function StrToBool(const S: string): Boolean;
function StrToBoolDef(const S: string; const Default: Boolean): Boolean;
function TryStrToBool(const S: string; out Value: Boolean): Boolean;
function BoolToStr(B: Boolean; UseBoolStrs: Boolean = False): string;
function LoadStr(Ident: Integer): string;
function FmtLoadStr(Ident: Integer; const Args: array of const): string;
function FileOpen(const FileName: string; Mode: LongWord): Integer;
function FileCreate(const FileName: string): Integer; overload;
function FileCreate(const FileName: string; Rights: Integer): Integer; overload;
function FileRead(Handle: Integer; var Buffer; Count: LongWord): Integer;
function FileWrite(Handle: Integer; const Buffer; Count: LongWord): Integer;
function FileSeek(Handle, Offset, Origin: Integer): Integer; overload;
function FileSeek(Handle: Integer; const Offset: Int64; Origin: Integer): Int64; overload;
procedure FileClose(Handle: Integer);
function FileAge(const FileName: string): Integer;
function FileExists(const FileName: string): Boolean;
function DirectoryExists(const Directory: string): Boolean;
function ForceDirectories(Dir: string): Boolean;
function FindFirst(const Path: string; Attr: Integer; var F: TSearchRec): Integer;
function FindNext(var F: TSearchRec): Integer;
procedure FindClose(var F: TSearchRec);
function FileGetDate(Handle: Integer): Integer;
function FileSetDate(const FileName: string; Age: Integer): Integer; overload;
function FileSetDate(Handle: Integer; Age: Integer): Integer; overload; platform;
function FileGetAttr(const FileName: string): Integer; platform;
function FileSetAttr(const FileName: string; Attr: Integer): Integer; platform;
function FileIsReadOnly(const FileName: string): Boolean;
function FileSetReadOnly(const FileName: string; ReadOnly: Boolean): Boolean;
function DeleteFile(const FileName: string): Boolean;
function RenameFile(const OldName, NewName: string): Boolean;
function ChangeFileExt(const FileName, Extension: string): string;
function ExtractFilePath(const FileName: string): string;
function ExtractFileDir(const FileName: string): string;
function ExtractFileDrive(const FileName: string): string;
function ExtractFileName(const FileName: string): string;
function ExtractFileExt(const FileName: string): string;
function ExpandFileName(const FileName: string): string;
function ExpandFileNameCase(const FileName: string; out MatchFound: TFilenameCaseMatch): string;
function ExpandUNCFileName(const FileName: string): string;
function ExtractRelativePath(const BaseName, DestName: string): string;
function ExtractShortPathName(const FileName: string): string;
function FileSearch(const Name, DirList: string): string;
function DiskFree(Drive: Byte): Int64;
function DiskSize(Drive: Byte): Int64;
function FileDateToDateTime(FileDate: Integer): TDateTime;
function DateTimeToFileDate(DateTime: TDateTime): Integer;
function GetCurrentDir: string;
function SetCurrentDir(const Dir: string): Boolean;
function CreateDir(const Dir: string): Boolean;
function RemoveDir(const Dir: string): Boolean;
function StrLen(const Str: PChar): Cardinal;
function StrEnd(const Str: PChar): PChar;
function StrMove(Dest: PChar; const Source: PChar; Count: Cardinal): PChar;
function StrCopy(Dest: PChar; const Source: PChar): PChar;
function StrECopy(Dest:PChar; const Source: PChar): PChar;
function StrLCopy(Dest: PChar; const Source: PChar; MaxLen: Cardinal): PChar;
function StrPCopy(Dest: PChar; const Source: string): PChar;
function StrPLCopy(Dest: PChar; const Source: string; MaxLen: Cardinal): PChar;
function StrCat(Dest: PChar; const Source: PChar): PChar;
function StrLCat(Dest: PChar; const Source: PChar; MaxLen: Cardinal): PChar;
function StrComp(const Str1, Str2: PChar): Integer;
function StrIComp(const Str1, Str2: PChar): Integer;
function StrLComp(const Str1, Str2: PChar; MaxLen: Cardinal): Integer;
function StrLIComp(const Str1, Str2: PChar; MaxLen: Cardinal): Integer;
function StrScan(const Str: PChar; Chr: Char): PChar;
function StrRScan(const Str: PChar; Chr: Char): PChar;
function StrPos(const Str1, Str2: PChar): PChar;
function StrUpper(Str: PChar): PChar;
function StrLower(Str: PChar): PChar;
function StrPas(const Str: PChar): string;
function StrAlloc(Size: Cardinal): PChar;
function StrBufSize(const Str: PChar): Cardinal;
function StrNew(const Str: PChar): PChar;
procedure StrDispose(Str: PChar);
function Format(const Format: string; const Args: array of const): string;
procedure FmtStr(var Result: string; const Format: string; const Args: array of const);
function StrFmt(Buffer, Format: PChar; const Args: array of const): PChar;
function StrLFmt(Buffer: PChar; MaxBufLen: Cardinal; Format: PChar; const Args: array of const): PChar;
function FormatBuf(var Buffer; BufLen: Cardinal; const Format; FmtLen: Cardinal; const Args: array of const): Cardinal;
function WideFormat(const Format: WideString; const Args: array of const): WideString;
procedure WideFmtStr(var Result: WideString; const Format: WideString; const Args: array of const);
function WideFormatBuf(var Buffer; BufLen: Cardinal; const Format; FmtLen: Cardinal; const Args: array of const): Cardinal;
function FloatToStr(Value: Extended): string;
function CurrToStr(Value: Currency): string;
function FloatToCurr(const Value: Extended): Currency;
function FloatToStrF(Value: Extended; Format: TFloatFormat; Precision, Digits: Integer): string;
function CurrToStrF(Value: Currency; Format: TFloatFormat; Digits: Integer): string;
function FloatToText(BufferArg: PChar; const Value; ValueType: TFloatValue; Format: TFloatFormat; Precision, Digits: Integer): Integer;
function FormatFloat(const Format: string; Value: Extended): string;
function FormatCurr(const Format: string; Value: Currency): string;
function FloatToTextFmt(Buf: PChar; const Value; ValueType: TFloatValue; Format: PChar): Integer;
function StrToFloat(const S: string): Extended;
function StrToFloatDef(const S: string; const Default: Extended): Extended;
function TryStrToFloat(const S: string; out Value: Extended): Boolean; overload;
function TryStrToFloat(const S: string; out Value: Double): Boolean; overload;
function TryStrToFloat(const S: string; out Value: Single): Boolean; overload;
function StrToCurr(const S: string): Currency;
function StrToCurrDef(const S: string; const Default: Currency): Currency;
function TryStrToCurr(const S: string; out Value: Currency): Boolean;
function TextToFloat(Buffer: PChar; var Value; ValueType: TFloatValue): Boolean;
procedure FloatToDecimal(var Result: TFloatRec; const Value; ValueType: TFloatValue; Precision, Decimals: Integer);
function DateTimeToTimeStamp(DateTime: TDateTime): TTimeStamp;
function TimeStampToDateTime(const TimeStamp: TTimeStamp): TDateTime;
function MSecsToTimeStamp(MSecs: Comp): TTimeStamp;
function TimeStampToMSecs(const TimeStamp: TTimeStamp): Comp;
function EncodeDate(Year, Month, Day: Word): TDateTime;
function EncodeTime(Hour, Min, Sec, MSec: Word): TDateTime;
function TryEncodeDate(Year, Month, Day: Word; out Date: TDateTime): Boolean;
function TryEncodeTime(Hour, Min, Sec, MSec: Word; out Time: TDateTime): Boolean;
procedure DecodeDate(const DateTime: TDateTime; var Year, Month, Day: Word);
function DecodeDateFully(const DateTime: TDateTime; var Year, Month, Day, DOW: Word): Boolean;
function InternalDecodeDate(const DateTime: TDateTime; var Year, Month, Day, DOW: Word): Boolean;
procedure DecodeTime(const DateTime: TDateTime; var Hour, Min, Sec, MSec: Word);
procedure DateTimeToSystemTime(const DateTime: TDateTime; var SystemTime: TSystemTime);
function SystemTimeToDateTime(const SystemTime: TSystemTime): TDateTime;
function DayOfWeek(const DateTime: TDateTime): Word;
function Date: TDateTime;
function Time: TDateTime;
function Now: TDateTime;
function CurrentYear: Word;
function IncMonth(const DateTime: TDateTime; NumberOfMonths: Integer = 1): TDateTime;
procedure IncAMonth(var Year, Month, Day: Word; NumberOfMonths: Integer = 1);
procedure ReplaceTime(var DateTime: TDateTime; const NewTime: TDateTime);
procedure ReplaceDate(var DateTime: TDateTime; const NewDate: TDateTime);
function IsLeapYear(Year: Word): Boolean;
function DateToStr(const DateTime: TDateTime): string;
function TimeToStr(const DateTime: TDateTime): string;
function DateTimeToStr(const DateTime: TDateTime): string;
function StrToDate(const S: string): TDateTime;
function StrToDateDef(const S: string; const Default: TDateTime): TDateTime;
function TryStrToDate(const S: string; out Value: TDateTime): Boolean;
function StrToTime(const S: string): TDateTime;
function StrToTimeDef(const S: string; const Default: TDateTime): TDateTime;
function TryStrToTime(const S: string; out Value: TDateTime): Boolean;
function StrToDateTime(const S: string): TDateTime;
function StrToDateTimeDef(const S: string; const Default: TDateTime): TDateTime;
function TryStrToDateTime(const S: string; out Value: TDateTime): Boolean;
function FormatDateTime(const Format: string; DateTime: TDateTime): string;
procedure DateTimeToString(var Result: string; const Format: string; DateTime: TDateTime);
function FloatToDateTime(const Value: Extended): TDateTime;
function SysErrorMessage(ErrorCode: Integer): string;
function GetLocaleStr(Locale, LocaleType: Integer; const Default: string): string; platform;
function GetLocaleChar(Locale, LocaleType: Integer; Default: Char): Char; platform;
procedure GetFormatSettings;
function InquireSignal(RtlSigNum: Integer): TSignalState;
procedure AbandonSignalHandler(RtlSigNum: Integer);
procedure HookSignal(RtlSigNum: Integer);
procedure UnhookSignal(RtlSigNum: Integer; OnlyIfHooked: Boolean = True);
procedure HookOSExceptions;
function MapSignal(SigNum: Integer; Context: PSigContext): LongWord;
procedure SignalConverter(ExceptionEIP: LongWord; FaultAddr: LongWord; ErrorCode: LongWord);
procedure SetSafeCallExceptionMsg(Msg: String);
procedure SetSafeCallExceptionAddr(Addr: Pointer);
function GetSafeCallExceptionMsg: String;
function GetSafeCallExceptionAddr: Pointer;
function LoadLibrary(ModuleName: PChar): HMODULE;
function FreeLibrary(Module: HMODULE): LongBool;
function GetProcAddress(Module: HMODULE; Proc: PChar): Pointer;
function GetModuleHandle(ModuleName: PChar): HMODULE;
function GetPackageModuleHandle(PackageName: PChar): HMODULE;
procedure Sleep(milliseconds: Cardinal);{$IFDEF MSWINDOWS} stdcall; {$ENDIF}
function GetModuleName(Module: HMODULE): string;
function ExceptionErrorMessage(ExceptObject: TObject; ExceptAddr: Pointer; Buffer: PChar; Size: Integer): Integer;
procedure ShowException(ExceptObject: TObject; ExceptAddr: Pointer);
procedure Abort;
procedure OutOfMemoryError;
procedure Beep;
function ByteType(const S: string; Index: Integer): TMbcsByteType;
function StrByteType(Str: PChar; Index: Cardinal): TMbcsByteType;
function ByteToCharLen(const S: string; MaxLen: Integer): Integer;
function CharToByteLen(const S: string; MaxLen: Integer): Integer;
function ByteToCharIndex(const S: string; Index: Integer): Integer;
function CharToByteIndex(const S: string; Index: Integer): Integer;
function StrCharLength(const Str: PChar): Integer;
function StrNextChar(const Str: PChar): PChar;
function CharLength(const S: String; Index: Integer): Integer;
function NextCharIndex(const S: String; Index: Integer): Integer;
function IsPathDelimiter(const S: string; Index: Integer): Boolean;
function IsDelimiter(const Delimiters, S: string; Index: Integer): Boolean;
function IncludeTrailingPathDelimiter(const S: string): string;
function IncludeTrailingBackslash(const S: string): string; platform;
function ExcludeTrailingPathDelimiter(const S: string): string;
function ExcludeTrailingBackslash(const S: string): string; platform;
function LastDelimiter(const Delimiters, S: string): Integer;
function AnsiCompareFileName(const S1, S2: string): Integer;
function SameFileName(const S1, S2: string): Boolean;
function AnsiLowerCaseFileName(const S: string): string;
function AnsiUpperCaseFileName(const S: string): string;
function AnsiPos(const Substr, S: string): Integer;
function AnsiStrPos(Str, SubStr: PChar): PChar;
function AnsiStrRScan(Str: PChar; Chr: Char): PChar;
function AnsiStrScan(Str: PChar; Chr: Char): PChar;
function StringReplace(const S, OldPattern, NewPattern: string; Flags: TReplaceFlags): string;
function WrapText(const Line, BreakStr: string; const BreakChars: TSysCharSet; MaxCol: Integer): string; overload;
function WrapText(const Line: string; MaxCol: Integer = 45): string; overload;
function FindCmdLineSwitch(const Switch: string; const Chars: TSysCharSet; IgnoreCase: Boolean): Boolean; overload;
function FindCmdLineSwitch(const Switch: string): Boolean; overload;
function FindCmdLineSwitch(const Switch: string; IgnoreCase: Boolean): Boolean; overload;
procedure FreeAndNil(var Obj);
function Supports(const Instance: IInterface; const IID: TGUID; out Intf): Boolean; overload;
function Supports(const Instance: TObject; const IID: TGUID; out Intf): Boolean; overload;
function Supports(const Instance: IInterface; const IID: TGUID): Boolean; overload;
function Supports(const Instance: TObject; const IID: TGUID): Boolean; overload;
function Supports(const AClass: TClass; const IID: TGUID): Boolean; overload;
function CreateGUID(out Guid: TGUID): HResult;
function StringToGUID(const S: string): TGUID;
function GUIDToString(const GUID: TGUID): string;
function IsEqualGUID(const guid1, guid2: TGUID): Boolean;
function LoadPackage(const Name: string): HMODULE;
procedure UnloadPackage(Module: HMODULE);
procedure GetPackageInfo(Module: HMODULE; Param: Pointer; var Flags: Integer; InfoProc: TPackageInfoProc);
function GetPackageDescription(ModuleName: PChar): string;
procedure InitializePackage(Module: HMODULE);
procedure FinalizePackage(Module: HMODULE);
procedure RaiseLastOSError;
procedure RaiseLastWin32Error; deprecated;
function Win32Check(RetVal: BOOL): BOOL; platform;
procedure AddTerminateProc(TermProc: TTerminateProc);
function CallTerminateProcs: Boolean;
function GDAL: LongWord;
procedure RCS;
procedure RPR;
function SafeLoadLibrary(const Filename: string; ErrorMode: UINT = SEM_NOOPENFILEERRORBOX): HMODULE;
function GetEnvironmentVariable(const Name: string): string; overload;
function InterlockedIncrement(var I: Integer): Integer;
function InterlockedDecrement(var I: Integer): Integer;
function InterlockedExchange(var A: Integer; B: Integer): Integer;
function InterlockedExchangeAdd(var A: Integer; B: Integer): Integer;

//system.pas
function GetHeapBlocks: THeapBlockArray;
function FindObjects(AClass: TClass; FindDerived: Boolean): TObjectArray;
function AcquireExceptionObject: Pointer;
procedure ReleaseExceptionObject;
procedure GetUnwinder(var Dest: TUnwinder);
procedure SetUnwinder(const NewUnwinder: TUnwinder);
function IsUnwinderSet: Boolean;
function SysRegisterIPLookup(StartAddr, EndAddr: LongInt; Context: Pointer; GOT: LongInt): LongBool;
procedure SysUnregisterIPLookup(StartAddr: LongInt);
function SysClosestDelphiHandler(Context: Pointer): LongWord;
procedure BlockOSExceptions;
procedure UnblockOSExceptions;
function AreOSExceptionsBlocked: Boolean;
function RaiseList: Pointer; deprecated; { Stack of current exception objects }
function SetRaiseList(NewPtr: Pointer): Pointer; deprecated; { returns previous value }
function ExceptObject: TObject;
function ExceptAddr: Pointer;
procedure SetInOutRes(NewValue: Integer);
function FindResource(ModuleHandle: HMODULE; ResourceName, ResourceType: PChar): TResourceHandle;
function LoadResource(ModuleHandle: HMODULE; ResHandle: TResourceHandle): HGLOBAL;
function SizeofResource(ModuleHandle: HMODULE; ResHandle: TResourceHandle): Integer;
function LockResource(ResData: HGLOBAL): Pointer;
function UnlockResource(ResData: HGLOBAL): LongBool;
function FreeResource(ResData: HGLOBAL): LongBool;
procedure GetMemoryManager(var MemMgr: TMemoryManager);
procedure SetMemoryManager(const MemMgr: TMemoryManager);
function IsMemoryManagerSet: Boolean;
function SysGetMem(Size: Integer): Pointer;
function SysFreeMem(P: Pointer): Integer;
function SysReallocMem(P: Pointer; Size: Integer): Pointer;
function GetHeapStatus: THeapStatus; platform;
function BeginThread(SecurityAttributes: Pointer; StackSize: LongWord; ThreadFunc: TThreadFunc; Parameter: Pointer; CreationFlags: LongWord; var ThreadId: LongWord): Integer;
function BeginThread(Attribute: PThreadAttr; ThreadFunc: TThreadFunc; Parameter: Pointer; var ThreadId: Cardinal): Integer;
procedure EndThread(ExitCode: Integer);
procedure SetLineBreakStyle(var T: Text; Style: TTextLineBreakStyle);
procedure ChDir(const S: string); overload;
procedure ChDir(P: PChar); overload;
function Flush(var t: Text): Integer;
function IOResult: Integer;
procedure MkDir(const S: string); overload;
procedure MkDir(P: PChar); overload;
procedure Move(const Source; var Dest; Count: Integer);
function ParamCount: Integer;
function ParamStr(Index: Integer): string;
procedure Randomize;
procedure RmDir(const S: string); overload;
procedure RmDir(P: PChar); overload;
function UpCase(Ch: Char): Char;
procedure Set8087CW(NewCW: Word);
function Get8087CW: Word;
function WideCharToString(Source: PWideChar): string;
function WideCharLenToString(Source: PWideChar; SourceLen: Integer): string;
procedure WideCharToStrVar(Source: PWideChar; var Dest: string);
procedure WideCharLenToStrVar(Source: PWideChar; SourceLen: Integer; var Dest: string);
function StringToWideChar(const Source: string; Dest: PWideChar; DestSize: Integer): PWideChar;
function PUCS4Chars(const S: UCS4String): PUCS4Char;
function WideStringToUCS4String(const S: WideString): UCS4String;
function UCS4StringToWideString(const S: UCS4String): WideString;
function UnicodeToUtf8(Dest: PChar; Source: PWideChar; MaxBytes: Integer): Integer; overload; deprecated;
function Utf8ToUnicode(Dest: PWideChar; Source: PChar; MaxChars: Integer): Integer; overload; deprecated;
function UnicodeToUtf8(Dest: PChar; MaxDestBytes: Cardinal; Source: PWideChar; SourceChars: Cardinal): Cardinal; overload;
function Utf8ToUnicode(Dest: PWideChar; MaxDestChars: Cardinal; Source: PChar; SourceBytes: Cardinal): Cardinal; overload;
function UTF8Encode(const WS: WideString): UTF8String;
function UTF8Decode(const S: UTF8String): WideString;
function AnsiToUtf8(const S: string): UTF8String;
function Utf8ToAnsi(const S: UTF8String): string;
function OleStrToString(Source: PWideChar): string;
procedure OleStrToStrVar(Source: PWideChar; var Dest: string);
function StringToOleStr(const Source: string): PWideChar;
procedure GetVariantManager(var VarMgr: TVariantManager);
procedure SetVariantManager(const VarMgr: TVariantManager);
function IsVariantManagerSet: Boolean;
procedure RegisterModule(LibModule: PLibModule);
procedure UnregisterModule(LibModule: PLibModule);
function FindHInstance(Address: Pointer): LongWord;
function FindClassHInstance(ClassType: TClass): LongWord;
function FindResourceHInstance(Instance: LongWord): LongWord;
function LoadResourceModule(ModuleName: PChar; CheckOwner: Boolean = True): LongWord;
procedure EnumModules(Func: TEnumModuleFunc; Data: Pointer); overload;
procedure EnumResourceModules(Func: TEnumModuleFunc; Data: Pointer); overload;
procedure EnumModules(Func: TEnumModuleFuncLW; Data: Pointer); overload;
procedure EnumResourceModules(Func: TEnumModuleFuncLW; Data: Pointer); overload;
procedure AddModuleUnloadProc(Proc: TModuleUnloadProc); overload;
procedure RemoveModuleUnloadProc(Proc: TModuleUnloadProc); overload;
procedure AddModuleUnloadProc(Proc: TModuleUnloadProcLW); overload;
procedure RemoveModuleUnloadProc(Proc: TModuleUnloadProcLW); overload;
function GetModuleFileName(Module: HMODULE; Buffer: PChar; BufLen: Integer): Integer;
function LoadResString(ResStringRec: PResStringRec): string;
function _BlockWrite(var f: TFileRec; buffer: Pointer; recCnt: Longint; var recsWritten: Longint): Longint;
procedure Mark; deprecated;
procedure Release; deprecated;
procedure UniqueString(var str: AnsiString); overload;
procedure UniqueString(var str: WideString); overload;
procedure DynArrayClear(var a: Pointer; typeInfo: Pointer);
procedure DynArraySetLength(var a: Pointer; typeInfo: Pointer; dimCnt: Longint; lengthVec: PLongint);
function DynArrayDim(typeInfo: PDynArrayTypeInfo): Integer;
procedure FPower10;
procedure TextStart; deprecated;
function CompToDouble(Value: Comp): Double; cdecl;
procedure DoubleToComp(Value: Double; var Result: Comp); cdecl;
function CompToCurrency(Value: Comp): Currency; cdecl;
procedure CurrencyToComp(Value: Currency; var Result: Comp); cdecl;
function GetMemory(Size: Integer): Pointer; cdecl;
function FreeMemory(P: Pointer): Integer; cdecl;
function ReallocMemory(P: Pointer; Size: Integer): Pointer; cdecl;
procedure Error(errorCode: TRuntimeError);
function GetLastError: Integer; {$IFDEF MSWINDOWS} stdcall; {$ENDIF}
procedure SetLastError(ErrorCode: Integer); {$IFDEF MSWINDOWS} stdcall; {$ENDIF}
function ModuleCacheID: Cardinal;
procedure InvalidateModuleCache;
procedure DbgUnlockX;

#2

//VarUtils.pas
function VariantInit(var V: TVarData): HRESULT; stdcall;
function VariantClear(var V: TVarData): HRESULT; stdcall;
function VariantCopy(var Dest: TVarData; const Source: TVarData): HRESULT; stdcall;
function VariantCopyInd(var Dest: TVarData; const Source: TVarData): HRESULT; stdcall;
function VariantChangeTypeEx(var Dest: TVarData; const Source: TVarData; LCID: Integer; Flags: Word; VarType: Word): HRESULT; stdcall;
function SafeArrayCreate(VarType, DimCount: Integer; const Bounds: TVarArrayBoundArray): PVarArray; stdcall;
function SafeArrayAllocDescriptor(DimCount: Integer; out VarArray: PVarArray): HRESULT; stdcall;
function SafeArrayAllocData(VarArray: PVarArray): HRESULT; stdcall;
function SafeArrayDestroy(VarArray: PVarArray): HRESULT; stdcall;
function SafeArrayDestroyDescriptor(VarArray: PVarArray): HRESULT; stdcall;
function SafeArrayDestroyData(VarArray: PVarArray): HRESULT; stdcall;
function SafeArrayRedim(VarArray: PVarArray; const NewBound: TVarArrayBound): HRESULT; stdcall;
function SafeArrayCopy(SourceArray: PVarArray; out TargetArray: PVarArray): HRESULT; stdcall;
function SafeArrayCopyData(SourceArray, TargetArray: PVarArray): HRESULT; stdcall;
function SafeArrayGetLBound(VarArray: PVarArray; Dim: Integer; out LBound: Integer): HRESULT; stdcall;
function SafeArrayGetUBound(VarArray: PVarArray; Dim: Integer; out UBound: Integer): HRESULT; stdcall;
function SafeArrayGetDim(VarArray: PVarArray): Integer; stdcall;
function SafeArrayAccessData(VarArray: PVarArray; out Data: Pointer): HRESULT; stdcall;
function SafeArrayUnaccessData(VarArray: PVarArray): HRESULT; stdcall;
function SafeArrayLock(VarArray: PVarArray): HRESULT; stdcall;
function SafeArrayUnlock(VarArray: PVarArray): HRESULT; stdcall;
function SafeArrayGetElement(VarArray: PVarArray; Indices: PVarArrayCoorArray; Data: Pointer): HRESULT; stdcall;
function SafeArrayPutElement(VarArray: PVarArray; Indices: PVarArrayCoorArray; const Data: Pointer): HRESULT; stdcall;
function SafeArrayPtrOfIndex(VarArray: PVarArray; Indices: PVarArrayCoorArray; var Address: Pointer): HRESULT; stdcall;
function SafeArrayGetElemSize(VarArray: PVarArray): LongWord; stdcall;

#3

//StrUtils.pas
function AnsiResemblesText(const AText, AOther: string): Boolean;
function AnsiContainsText(const AText, ASubText: string): Boolean;
function AnsiStartsText(const ASubText, AText: string): Boolean;
function AnsiEndsText(const ASubText, AText: string): Boolean;
function AnsiReplaceText(const AText, AFromText, AToText: string): string;
function AnsiMatchText(const AText: string; const AValues: array of string): Boolean;
function AnsiIndexText(const AText: string; const AValues: array of string): Integer;
function AnsiContainsStr(const AText, ASubText: string): Boolean;
function AnsiStartsStr(const ASubText, AText: string): Boolean;
function AnsiEndsStr(const ASubText, AText: string): Boolean;
function AnsiReplaceStr(const AText, AFromText, AToText: string): string;
function AnsiMatchStr(const AText: string; const AValues: array of string): Boolean;
function AnsiIndexStr(const AText: string; const AValues: array of string): Integer;
function DupeString(const AText: string; ACount: Integer): string;
function ReverseString(const AText: string): string;
function StuffString(const AText: string; AStart, ALength: Cardinal; const ASubText: string): string;
function RandomFrom(const AValues: array of string): string; overload;
function IfThen(AValue: Boolean; const ATrue: string; AFalse: string = ''): string; overload;
function LeftStr(const AText: string; const ACount: Integer): string;
function RightStr(const AText: string; const ACount: Integer): string;
function MidStr(const AText: string; const AStart, ACount: Integer): string;
function SearchBuf(Buf: PChar; BufLen: Integer; SelStart, SelLength: Integer; SearchString: String; Options: TStringSearchOptions = [soDown]): PChar;
function Soundex(const AText: string; ALength: TSoundexLength = 4): string;
function SoundexInt(const AText: string; ALength: TSoundexIntLength = 4): Integer;
function DecodeSoundexInt(AValue: Integer): string;
function SoundexWord(const AText: string): Word;
function DecodeSoundexWord(AValue: Word): string;
function SoundexSimilar(const AText, AOther: string; ALength: TSoundexLength = 4): Boolean;
function SoundexCompare(const AText, AOther: string; ALength: TSoundexLength = 4): Integer;
function SoundexProc(const AText, AOther: string): Boolean;

#4

咣当～～～～

#5

//math.pas
function ArcCos(const X: Extended): Extended; { IN: |X| <= 1 OUT: [0..PI] radians }
function ArcSin(const X: Extended): Extended; { IN: |X| <= 1 OUT: [-PI/2..PI/2] radians }
function ArcTan2(const Y, X: Extended): Extended;
procedure SinCos(const Theta: Extended; var Sin, Cos: Extended) register;
function Tan(const X: Extended): Extended;
function Cotan(const X: Extended): Extended; { 1 / tan(X), X <> 0 }
function Secant(const X: Extended): Extended; { 1 / cos(X) }
function Cosecant(const X: Extended): Extended; { 1 / sin(X) }
function Hypot(const X, Y: Extended): Extended; { Sqrt(X**2 + Y**2) }
function RadToDeg(const Radians: Extended): Extended; { Degrees := Radians * 180 / PI }
function RadToGrad(const Radians: Extended): Extended; { Grads := Radians * 200 / PI }
function RadToCycle(const Radians: Extended): Extended;{ Cycles := Radians / 2PI }
function DegToRad(const Degrees: Extended): Extended; { Radians := Degrees * PI / 180}
function DegToGrad(const Degrees: Extended): Extended;
function DegToCycle(const Degrees: Extended): Extended;
function GradToRad(const Grads: Extended): Extended; { Radians := Grads * PI / 200 }
function GradToDeg(const Grads: Extended): Extended;
function GradToCycle(const Grads: Extended): Extended;
function CycleToRad(const Cycles: Extended): Extended; { Radians := Cycles * 2PI }
function CycleToDeg(const Cycles: Extended): Extended;
function CycleToGrad(const Cycles: Extended): Extended;
function Cot(const X: Extended): Extended; { simply calls Cotan }
function Sec(const X: Extended): Extended; { simply calls Secant }
function Csc(const X: Extended): Extended; { simply calls Cosecant }
function Cosh(const X: Extended): Extended;
function Sinh(const X: Extended): Extended;
function Tanh(const X: Extended): Extended;
function CotH(const X: Extended): Extended;
function SecH(const X: Extended): Extended;
function CscH(const X: Extended): Extended;
function ArcCot(const X: Extended): Extended;
function ArcSec(const X: Extended): Extended;
function ArcCsc(const X: Extended): Extended;
function ArcCosh(const X: Extended): Extended; { IN: X >= 1 }
function ArcSinh(const X: Extended): Extended;
function ArcTanh(const X: Extended): Extended; { IN: |X| <= 1 }
function ArcCotH(const X: Extended): Extended;
function ArcSecH(const X: Extended): Extended;
function ArcCscH(const X: Extended): Extended;
function LnXP1(const X: Extended): Extended; { Ln(X + 1), accurate for X near zero }
function Log10(const X: Extended): Extended; { Log base 10 of X }
function Log2(const X: Extended): Extended; { Log base 2 of X }
function LogN(const Base, X: Extended): Extended; { Log base N of X }
function IntPower(const Base: Extended; const Exponent: Integer): Extended register;
function Power(const Base, Exponent: Extended): Extended;
procedure Frexp(const X: Extended; var Mantissa: Extended; var Exponent: Integer) register;
function Ldexp(const X: Extended; const P: Integer): Extended register;
function Ceil(const X: Extended):Integer;
function Floor(const X: Extended): Integer;
function Poly(const X: Extended; const Coefficients: array of Double): Extended;
function Mean(const Data: array of Double): Extended;
function Sum(const Data: array of Double): Extended register;
function SumInt(const Data: array of Integer): Integer register;
function SumOfSquares(const Data: array of Double): Extended;
procedure SumsAndSquares(const Data: array of Double; var Sum, SumOfSquares: Extended) register;
function MinValue(const Data: array of Double): Double;
function MinIntValue(const Data: array of Integer): Integer;
function Min(const A, B: Integer): Integer; overload;
function Min(const A, B: Int64): Int64; overload;
function Min(const A, B: Single): Single; overload;
function Min(const A, B: Double): Double; overload;
function Min(const A, B: Extended): Extended; overload;
function MaxValue(const Data: array of Double): Double;
function MaxIntValue(const Data: array of Integer): Integer;
function Max(const A, B: Integer): Integer; overload;
function Max(const A, B: Int64): Int64; overload;
function Max(const A, B: Single): Single; overload;
function Max(const A, B: Double): Double; overload;
function Max(const A, B: Extended): Extended; overload;
function StdDev(const Data: array of Double): Extended;
procedure MeanAndStdDev(const Data: array of Double; var Mean, StdDev: Extended);
function PopnStdDev(const Data: array of Double): Extended;
function Variance(const Data: array of Double): Extended;
function PopnVariance(const Data: array of Double): Extended;
function TotalVariance(const Data: array of Double): Extended;
function Norm(const Data: array of Double): Extended;
procedure MomentSkewKurtosis(const Data: array of Double; var M1, M2, M3, M4, Skew, Kurtosis: Extended);
function RandG(Mean, StdDev: Extended): Extended;
function IsNan(const AValue: Double): Boolean;
function IsInfinite(const AValue: Double): Boolean;
function Sign(const AValue: Integer): TValueSign; overload;
function Sign(const AValue: Int64): TValueSign; overload;
function Sign(const AValue: Double): TValueSign; overload;
function CompareValue(const A, B: Extended; Epsilon: Extended = 0): TValueRelationship; overload;
function CompareValue(const A, B: Double; Epsilon: Double = 0): TValueRelationship; overload;
function CompareValue(const A, B: Single; Epsilon: Single = 0): TValueRelationship; overload;
function CompareValue(const A, B: Integer): TValueRelationship; overload;
function CompareValue(const A, B: Int64): TValueRelationship; overload;
function SameValue(const A, B: Extended; Epsilon: Extended = 0): Boolean; overload;
function SameValue(const A, B: Double; Epsilon: Double = 0): Boolean; overload;
function SameValue(const A, B: Single; Epsilon: Single = 0): Boolean; overload;
function IsZero(const A: Extended; Epsilon: Extended = 0): Boolean; overload;
function IsZero(const A: Double; Epsilon: Double = 0): Boolean; overload;
function IsZero(const A: Single; Epsilon: Single = 0): Boolean; overload;
function IfThen(AValue: Boolean; const ATrue: Integer; const AFalse: Integer = 0): Integer; overload;
function IfThen(AValue: Boolean; const ATrue: Int64; const AFalse: Int64 = 0): Int64; overload;
function IfThen(AValue: Boolean; const ATrue: Double; const AFalse: Double = 0.0): Double; overload;
function RandomRange(const AFrom, ATo: Integer): Integer;
function RandomFrom(const AValues: array of Integer): Integer; overload;
function RandomFrom(const AValues: array of Int64): Int64; overload;
function RandomFrom(const AValues: array of Double): Double; overload;
function InRange(const AValue, AMin, AMax: Integer): Boolean; overload;
function InRange(const AValue, AMin, AMax: Int64): Boolean; overload;
function InRange(const AValue, AMin, AMax: Double): Boolean; overload;
function EnsureRange(const AValue, AMin, AMax: Integer): Integer; overload;
function EnsureRange(const AValue, AMin, AMax: Int64): Int64; overload;
function EnsureRange(const AValue, AMin, AMax: Double): Double; overload;
procedure DivMod(Dividend: Integer; Divisor: Word; var Result, Remainder: Word);
function RoundTo(const AValue: Double; const ADigit: TRoundToRange): Double;
function SimpleRoundTo(const AValue: Double; const ADigit: TRoundToRange = -2): Double;
function DoubleDecliningBalance(const Cost, Salvage: Extended; Life, Period: Integer): Extended;
function FutureValue(const Rate: Extended; NPeriods: Integer; const Payment, PresentValue: Extended; PaymentTime: TPaymentTime): Extended;
function InterestPayment(const Rate: Extended; Period, NPeriods: Integer; const PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function InterestRate(NPeriods: Integer; const Payment, PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function InternalRateOfReturn(const Guess: Extended; const CashFlows: array of Double): Extended;
function NumberOfPeriods(const Rate: Extended; Payment: Extended; const PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function NetPresentValue(const Rate: Extended; const CashFlows: array of Double; PaymentTime: TPaymentTime): Extended;
function Payment(Rate: Extended; NPeriods: Integer; const PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function PeriodPayment(const Rate: Extended; Period, NPeriods: Integer; const PresentValue, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function PresentValue(const Rate: Extended; NPeriods: Integer; const Payment, FutureValue: Extended; PaymentTime: TPaymentTime): Extended;
function SLNDepreciation(const Cost, Salvage: Extended; Life: Integer): Extended;
function SYDDepreciation(const Cost, Salvage: Extended; Life, Period: Integer): Extended;
function GetRoundMode: TFPURoundingMode;
function SetRoundMode(const RoundMode: TFPURoundingMode): TFPURoundingMode;
function GetPrecisionMode: TFPUPrecisionMode;
function SetPrecisionMode(const Precision: TFPUPrecisionMode): TFPUPrecisionMode;
function GetExceptionMask: TFPUExceptionMask;
function SetExceptionMask(const Mask: TFPUExceptionMask): TFPUExceptionMask;
procedure ClearExceptions;

#6

这些文字好像只要安装了delphi的机器里面都有吧..

能不能给点使用说明呢?请别让我一个个look up in delphi help,ok?

#7

咣当～～～～ 

#8

//....太多了
//....pascal原始函数....
Inc()
Dec()
Include()
Declude()
Str()
Val()
Succ()
Pred()
Round()
Trunc()
Odd()
//......

#9

zswang也，咣当～～～～ 

#10

既然多,那分数自然就要加了..
加分了!加分了!
哪位不吝赐教,必有重谢!

#11

函数多无所谓,只要心够诚,我相信还是有神仙哥哥姐姐们愿意赐教的哦:)

#12

我觉得一下子知道那么多也没有什么用处的～～你可以一边写程序一边搜索需要的函数～～

实在找不到就来ＣＳＤＮ阿～～呵呵

#13

其实字符串操作经常用的也就是
取长度Ｌｅｎｇｔｈ～～
Ｃｏｐｙ字符串Ｃｏｐｙ～～
查找Ｐｏｓ～～等等～～呵呵

#14

可是告诉各位一个事实:小弟还没用过呀...嘿嘿..惭愧,惭愧...
最好常用的,和比较常用的能给我说一下,好么?

#15

比如pos怎样用呢?

delphi6的帮助我觉得不如bcb作的好,只能用f1来显示,很多在help->delphi help里面根本没有

#16

我在市面上确实没有看见Delphi的函数手册
看来我要快点出一本
有哪个出版社有意
请留个电话与我联系!

#17

师兄阿～～
最好在配一个光盘
里面有一个程序～～
用来搜索函数阿～～
搜索一下想要的函数的中文～～
然后就能够找到类似函数的名称以及Ｄｅｍｏ的～～

#18

//广告☆☆☆☆☆☆☆☆<<Delphi6函数大全>>(附:光盘)☆☆☆☆☆☆☆☆☆☆
[标准函数和过程]
首部  procedure Abort;$[SysUtils
功能  引起放弃的意外处理。
说明  不显示任何错误信息。
&_
首部  function Abs(N: <Number>): <Number>;$[System
功能  返回参数N的绝对值。
说明  函数结果与参数有相同类型，参数可以是整型也可以是浮点型。
      ## Abs(-12) = 12；Abs(-12.03) = 12.03
&_
首部  procedure AddExitProc(Proc: TProcedure);$[SysUtils
功能  将旧版本某一过程添加到当前版本运行的库的结束过程表中。
说明  只能向下兼容，不能用在当前使用版本的
&_
首部  function Addr(X): Pointer;$[System  
功能  返回指定对象的内存地址。
说明  地址运算符 @ 可以产生与Addr相同的结果。
&_
首部  procedure AddTerminateProc(TermProc: TTerminateProc);$[SysUtils
功能  将一过程添加到运行时库的终止过程表中。
说明  Delphi 在程序结束时将终止该程序的全部进程，可以终止的进程都放在终止过程表中，
      程序通过结束终止过程表所有的进程来实现终止全部进程的目的。
&_
首部  function AdjustLineBreaks(const S: string): string;$[SysUtils
功能  将给定字符串的行分隔符调整为Cr/Lf序列。
说明  
&_
首部  function AllocMem(Size: Cardinal): Pointer;$[SysUtils
功能  在堆栈上分配给定大小为 Size字节的块，即在内存里开辟Size 大小的空间。
说明  Cardinal 0..4294967295 32位无符号整数
&_
首部  function AnsiCompareFileName(const S1, S2: string): Integer;$[SysUtils
功能  比较两个文件名的大小。不区分大小写。
说明  条件     返回值
      S1 > S2 | > 0
      S1 < S2 | < 0
      S1 = S2 | = 0
&_
首部  function AnsiCompareStr(const S1, S2: string): Integer;$[SysUtils
功能  比较两个字符串的大小。要区分大小写。
说明  参见AnsiCompareFileName。
&_
首部  function AnsiCompareText(const S1, S2: string): Integer;$[SysUtils
功能  返回两个字符串是否相同的状态。不区分大小写。
说明  参见AnsiCompareFileName。
&_
首部  function AnsiExtractQuotedStr(var Src: PChar; Quote: Char):string;$[SysUtils
功能  将引用字串转换成结束引语返回。
说明  函数支持多字节字符系统[MBCS]。
&_
首部  function AnsiLastChar(const S: string): PChar;$[SysUtils
功能  取参数S的最后一个字符，并转换成以null结束的字符串指针返回。
说明  ##AnsiLastChar(‘Sysoft’) = {‘t\0’};
&_
首部  function AnsiLowerCase(const S: string): string;$[SysUtils
功能  将字符串S转换为小写返回。
说明  函数支持多字节字符系统[MBCS]。
&_
首部  function AnsiLowerCaseFileName(const S: string): string;$[SysUtils
功能  将文件名S转换成小写返回
说明  函数支持多字节字符系统[MBCS]。
&_
首部  function AnsiPos(const Substr, S: string): Integer; $[SysUtils
功能  返回子串Substr出现在主串S中的第一个位置。
说明  
&_
首部  function AnsiQuotedStr(const S: string; Quote: Char): string; $[SysUtils
功能  返回引用字串的译文
说明  
&_
首部  function AnsiStrComp(S1, S2: PChar): Integer; $[SysUtils
功能  比较两个指针字符串的大小。要区分大小写。
说明  参见AnsiCompareFileName。
&_
首部  function AnsiStrIComp(S1, S2: PChar): Integer; $[SysUtils
功能  比较两个指针字符串的大小。不区分大小写。
说明  参见AnsiCompareFileName。
&_
首部  function AnsiStrLastChar(P: PChar): PChar; $[SysUtils
功能  返回字符串指针气所指向的最后一个字符位置
说明  
&_
首部  function AnsiStrLComp(S1, S2: PChar; MaxLen: Cardinal): Integer; $[SysUtils
功能  在最大长度MaxLen的范围内比较两个指针字符串的大小。要区分大小写。
说明  参见AnsiCompareFileName。
&_
首部  function AnsiStrLIComp(S1, S2: PChar; MaxLen: Cardinal): Integer; $[SysUnits
功能  在最大长度MaxLen的范围内比较两个指针字符串的大小。不区分大小写。
说明  参见AnsiCompareFileName。
&_
首部  function AnsiStrLower(Str: PChar): PChar; $[SysUtils
功能  将指针字符串S转换为小写返回。
说明  
&_
首部  function AnsiStrPos(Str, SubStr: PChar): PChar; $[SysUtils
功能  在指针字符串中返回子串Substr出现在主串S中的第一个位置。
说明  
&_
首部  function AnsiStrRScan(Str: PChar; Chr: Char): PChar; $[SysUtils
功能  返回以字符Chr在指针字符串Str中的最后一个位置为起始位置的指针字符串
说明  ## AnsiStrRScan(‘Zswangs1234567’, ‘s’) = ‘s1234567’;
&_
首部  function AnsiStrScan(Str: PChar; Chr: Char): PChar; $[SysUtils
功能  返回以字符Chr在指针字符串Str中的第一个位置为起始位置的指针字符串
说明  ## AnsiStrScan(‘Zswangs1234567’, ‘s’) = ‘swangs1234567’;
//...........
&_
首部  function Poly(X: Extended; const Coefficients: array of Double): Extended; $[Math
功能  {即：返回Coefficients[0] + Coefficients[1] * X + ... + Coefficients[N] * (X ** N)}
说明  
&_
首部  function PopnStdDev(const Data: array of Double): Extended; $[Math
功能  返回标准偏差入口值。
说明  此函数一般使用在商业和金融方面的计算。
&_
首部  function PopnVariance(const Data: array of Double): Extended; $[Math
功能  返回数组的平均值。{即：返回TotalVariance/N}
说明  参见TotalVariance。
&_
首部  function Pos(Substr, S: <String>): Integer; $[System
功能  返回子串Substr在主串S中的起始位置 。
说明  若S中不存在所述子串，则Pos返回值0。
&_
首部  function Power(Base, Exponent: Extended): Extended; $[Math
功能  返回参数Base的Exponent次方。{即：返回Base**Exponent}
说明  指数函数。
&_
首部  function Pred(X: <Ordinal>): <Ordinal>; $[System
功能  返回参数的前趋值。
说明  参数X可以是任何预定义的有序类型，也可为是用户构造的枚举类型。如果X已经是序列中的第一个数，并且进行范围检查的编译开关{$R}在开的位置，系统将触发一个导常。 ##Pred(‘c’) = ‘b’; Pred(True) = False;
&_
//...........


“师弟到时要你给我写几个范例哦！”

#19

我天～～这么多阿～～
看来一时半会是写不完的了～～
还好大部分Ｄｅｌｐｈｉ的帮助上都有的～～

#20

师弟,你玩过Menus.StripHotkey()吗？
还有很多函数大家都不知道
都不知道怎么找呀？？？？
所以这本书还是有点价值的

#21

师兄教诲的是～～我收藏～～

#22

go on..go on...

#23

嘻嘻嘻嘻嘻嘻嘻嘻嘻
嘻嘻嘻点心嘻嘻嘻嘻
嘻嘻嘻嘻嘻嘻嘻嘻嘻

#24

有没有啦??
怎么也得对得起我100分的诚意吧!

#25

砖嘻嘻嘻嘻嘻嘻嘻嘻
嘻嘻嘻嘻嘻嘻嘻嘻嘻
嘻嘻嘻嘻嘻嘻嘻嘻头

#26

//继续广告
//............
首部  function RemoveDir(const Dir: string): Boolean; $[SysUtils
功能  返回转移目录是否成功。
说明  如果转移成功则返回True，否则返回False。
&_
首部  procedure Rename(var F: <File>; Newname: string); $[System
功能  将与文件变量相联系的外部文件名更改为Newname
说明  在调用Rename之前，文件变量F应已与一当前外部文件名相联系。注意：在同一目录下要避免Newname与其它文件不同名。
&_
首部  function RenameFile(const OldName, NewName: string): Boolean; $[SysUtils
功能  对外部文件重命名，并返回改名是否成功。
说明  ## RenameFile(‘c:\pascal\zs.pas’, ‘c:\pascal\zs1.pas’);
&_
首部  procedure Reset(var F: File [; RecSize: Word ] ); $[System
功能  打开一个已存在的文件。
说明  实现读取的准备，将文件指针指向文件头。记录大小RecSize默认为128。
&_
首部  procedure Rewrite(var F: File [; Recsize: Word ] ); $[System
功能  建立并打开一新的文件 
说明  实现写入的准备，将文件指针指向文件头。记录大小RecSize默认为128。
&_
首部  procedure RmDir(S: string); $[System
功能  删除由参数S给定的子目录。
说明  所删除的子目录必须是一个空目录。可由IOReult检测调用RmDir是否成功。
&_
首部  function Round(X: Extended): Int64; $[System
功能  返回参数X的舍入整型值。{即：返回[X+0.5]}
说明  ##Round(1.4999) = 1; Round(1.500) = 2; Round(-1.4999) = -1; Round(-1.500) = -2;
&_
首部  procedure RunError [ ( Errorcode: Byte ) ]; $[System
功能  停止程序的执行。 
说明  不带参数时，对RunError的调用可以终止程序执行，但不给出特定的运行是的出错编码。带参数时，调用RunError将模拟程序对该错误的响应。
&_
首部  function SafeRef(vRefIn: OleVariant): OleVariant; safecall; $[Mtx
功能  返回一个可靠的对象变体。
说明  Mtx: 多任务执行程序。
&_
首部  procedure Seek(var F; N: Longint); $[System
功能  将文件指针定位至文件F中序号为N的元素处。
说明  规定文件的第一个元素其序号为0。
&_
首部  function SeekEof [ (var F: Text) ]: Boolean; $[System
功能  返回正文文件F的文件结束状态值。
说明  SeekEof与Eof功能  类似，但前者在返回文件结束状态值前将跳略所有空格符、制表符种行结束标志。这在从一正文文件中读取数字值时是非常有用。它也有助于避免读取正文末行之后的额外空白行。
&_
首部  function SeekEoln [ (var F: Text) ]: Boolean; $[System
功能  返回正文文件F的行结束状态值。
说明  SeekEoln与Eoln功能  类似，但前者在返回行结束状态值前将跳略所有空格符和制表符。这在从一正文文件中读取数字值时是非常有用。它也有助于避免读取每最后一个字符之后的额外空格符。
&_
首部  function SelectDirectory(var Directory: string; Options: TSelectDirOpts; HelpCtx: Longint): Boolean; overload; $[FileCtrl
      function SelectDirectory(const Caption: string; const Root: WideString; out Directory: string): Boolean; overload;
功能  显示一个选择路径的对话筐，返回用户是否选择路径。
说明  type
        TSelectDirOpt = (sdAllowCreate, sdPerformCreate, sdPrompt);
        TSelectDirOpts = set of TSelectDirOpt;
   ## const
   ## SELDIRHELP = 1000;
   ## procedure TForm1.Button1Click(Sender: TObject);
   ## var
   ##   Dir: string;
   ## begin
   ##   Dir := 'C:\MYDIR';
   ##   if SelectDirectory(Dir, [sdAllowCreate, sdPerformCreate, sdPrompt],SELDIRHELP) then
   ##      Label1.Caption := Dir;
   ## end;
&_
首部  procedure Set8087CW(NewCW: Word); $[System
功能  改变8087的指令代码Default8087CW。
说明  ## procedure NumericExample;
      ## var
      ##   Saved8087CW: Word;
      ## begin
      ##   Saved8087CW := Default8087CW;
      ##   Set8087CW($133f);  { Disable all fpu exceptions }
      ##   ThirdPartyRoutine;
      ##   Set8087CW(Saved8087CW);
      ## end;
&_
首部  procedure SetCaptureControl(Control: TControl); $[Controls
功能  指定元件获得全部鼠标的消息。
说明  ## SetCaptureControl(Form1);
&_
首部  function SetClipboard(NewClipboard: TClipboard): TClipboard; $[ clipbrd
功能  返回一个被替换的面版。
说明  
&_
首部  function SetCurrentDir(const Dir: string): Boolean; $[ SysUtils
功能  返回设置当前路径是否成功。
说明  
&_
首部  function SetErrorProc(ErrorProc: TSocketErrorProc): TSocketErrorProc; $[ScktComp
功能  用向Windows发错误消息替换一个异常处理。
说明  type TSocketErrorProc = procedure(ErrorCode: Integer);
&_
首部  procedure SetLength(var S; NewLength: Integer); $[System
功能  给字符串变量或开放性数组指定一个长度。
说明  ## var  s: string;  a: array of Integer;  begin  SetLength(s, 12);  SetLength(a, 2);  a[0] := 5;  a[1] := 3; end;
&_
//............

#27

当然自己能看help和source for delphi6是最好的
我只是想赚赚大家的钱

#28

我天～～呵呵～～

咦？我的笔记本呢？？～～我抄～～～

喂！！stanely(暗黑)　～～你别挡着我阿～～～

去～～（一脚踢开）～～

呵呵～～

#29

“呀，你怎么到我这里了”
(zswang拍了拍stanely(暗黑)的头)
“你的头没有小新的滑！”

#30

//还是广告
//............
首部  function StringOfChar(Ch: Char; Count: Integer): string; $[System
功能  将Ch复制Count资返回。
说明  ##StringOfChar('A', 10) = 'AAAAAAAAAA'
&_
首部  function StringReplace(const S, OldPattern, NewPattern: string; Flags: TReplaceFlags): string; $[SysUtils
功能  在字符串S将老字符串OldPattern用新字符NewPattern串取代返回。
说明  type TReplaceFlags = set of (rfReplaceAll, rfIgnore  Case);  Flags的值为rfReplaceAll则需要全字匹配，否则将忽略大小写。
&_
首部  function StringToColor(const S: string): TColor; $[Graphics
功能  将字符串转换成颜色类型返回。
说明  
&_
首部  function StringToCursor(const S: string): TCursor; $[controls
功能  将字符串转换成串行类型返回。
说明  type TCursor = -32768..32767;
&_
首部  function StringToGUID(const S: string): TGUID; $[ComObj
功能  将字符串转换成图形界面类型返回。
说明  
&_
首部  function StringToOleStr(const Source: string): PWideChar; $[System
功能  将Delphi的字符串转换成OLE格式返回。
说明  
&_
首部  function StringToWideChar(const Source: string; Dest: PWideChar; DestSize: Integer): PWideChar; $[System
功能  将Delphi的字符串转换成扩充字符串返回
说明  
&_
首部  function StripHotKey(const Text: string): string; $[Menus
功能  返回快捷键的标记。
说明  ## StripHotKey (‘&Close’) = ‘Close’;
//............

#31

有谁想和我一起写这本书的请报名！
你可以第一个得到这本书的原始稿

#32

ｔｉｋｋｙｐｅｎｇ从人群中奋力的挤了过来～～～～我！！！！我报名！！！！

#33

我可以吗，呵呵 

#34

拍嘻嘻嘻嘻嘻嘻嘻嘻
嘻嘻嘻嘻嘻嘻嘻嘻嘻
嘻嘻嘻嘻嘻嘻嘻嘻头

呵呵～～你？？在我后边好了～～呵呵

#35

原始稿请看上边的函数声明,翻译成首部、功能、说明和范例
(只听两声，咣当～～)

#36

to byrybye(阿水):
  留个E-Mail我发文档给你

#37

咣当～～～

师兄怎么不给我呢？

#38

师弟我已经给你发了
你打开附件看看

#39

那是Delphi 4的函数
现在，我们一个单元
一个单元的整理好吗？

#40

具体分工等byrybye(阿水)来后商议
//要买书的请报名
//前10个2折

#41

收到～～～～～～～～～～～

#42

http://www.csdn.net/expert/topic/397/397928.shtm

#43

我要1.5折

#44

该回复于2010-08-04 16:52:33被版主删除

#45

好的！我进去了你不要伤心，
要记得给我送永和豆浆！

#46

估计你是在也不能出来了～～呜～～

#47

嘻嘻嘻嘻嘻嘻嘻嘻嘻嘻嘻
嘻嘻嘻还会送书嘻嘻嘻嘻
嘻嘻嘻嘻嘻嘻嘻嘻嘻嘻嘻

#48

狂狼！
你个乌鸦嘴！
我还没去抢呢！
你的QQ呢？

#49

我..扑通...

#50

我