Где Взять класс С++ для работы с файлами более 2Гб.

OtD · 19 мар 2005

Ребята, помогите в поиске путёвого класса для работы с большими файлами. То есть с 64-х битными числами. И ещё желателен класс типа int64 и uint64. Пишу на С++.

Сам уже начал писать оба класса, но думаю это затянется.

Заранее Всем большое спасибо.

volodya · 19 мар 2005

с большими файлами. То есть с 64-х битными числами

но думаю это затянется

Ты прав. Во всяком случае до тех пор, пока ты не объяснишь нормальным человеческим языком, чего тебе надо?

1. С файлами или числами?

2. Что должен делать класс? Функциональность?

3. Предлагаемые методы?

flankerx · 19 мар 2005

класса для работы с большими файлами. То есть с 64-х битными числами
Нажмите, чтобы раскрыть...

классная логика а связь какая между этими двумя явлениями?

желателен класс типа int64
Нажмите, чтобы раскрыть...

в Mcrosoftовском Visual C++ есть встроенный тип __int64

Сам уже начал писать оба класса, но думаю это затянется
Нажмите, чтобы раскрыть...

Да, написать 64-битную арифметику с помощью готовой 32-х битной безумно сложно... минут 30, наверное, потратить нужно

OtD · 19 мар 2005

Ну, ребята Вы меня разгромили.

Попытаюсь более детально.

Поясню, я пишу на BC5 и у меня нет встроенного класса int64, по этому я предпологаю что где-то он есть в библиотеки, и он мне нужен.

Второе, мне нужен класс для работы с файлами более 2Гб, а это значит что опперирует этот класс 64-х битными целыми.

А написать класс int64 под 32-х битную машину за 30 минут это .

Вроде всё объяснил.

flankerx · 19 мар 2005

А написать класс int64 под 32-х битную машину за 30 минут это
Нажмите, чтобы раскрыть...

нет, это объективная реальность.

пару лет назад я видел нечто подобное 64-битное на sources.ru

amitophia · 19 мар 2005

OtD

У тебя BC5 или Borland C++ Builder 5?

В BCB5 есть __int64 (c двумя знаками подчёркивания перед int64)

OtD · 19 мар 2005

flankerx

"нет, это объективная реальность."

Ну как Вы так уважаемый, легко говорите. Только спецификация, заголовочного файла, отнимет у вас уйму времени.

amitophia

Нет не Builder 5, а BC5.

Не знаешь, он встроенный в BCB5 или в либе?

Спасибо.

volodya

"2. Что должен делать класс? Функциональность?"

Да пускай хотя бы простые стандартные операции под Win32 или как например TFile class.

volodya · 20 мар 2005

Да пускай хотя бы простые стандартные операции под Win32 или как например TFile class.

:-\

Мда... И еще раз, мда...

Стандартными WinAPI можно работать с файлами ЛЮБОЙ длины. Просто читай последовательно блоками, делай, что надо, записывай назад.

Я ведь не случайно задавал вопрос о функциональности... Ты сначала сам определись, что тебе нужно, а уж потом других на уши ставь

AsmGuru62 · 20 мар 2005

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winpr og/winprog/large_integer_str.asp

OtD · 20 мар 2005

Вот ты меня volodya прикалываешь, как в фильме: - "Он же памятник, кто ж его посадит."

На то я класс и ищу, чтобы с функциями Win32 не возиться, чтобы единая система обработки исключений была и другие полезности класса. Сам представляешь какой бардак будет с этими функциями.

Вопрос остаётся открытым, класс нужен. Наверно и не мне одному.

OtD · 20 мар 2005

AsmGuru62

Спасибо за ссылку, но там так и сказано что "Ваш С компилятор может поддерживать 64-битные целые".

Note Your C compiler may support 64-bit integers natively. For example, Microsoft® Visual C++® supports the __int64 sized integer type. For more information, see the documentation included with your C compiler.

А у меня не поддерживает BC5.

flankerx · 20 мар 2005

Ну как Вы так уважаемый, легко говорите. Только спецификация, заголовочного файла, отнимет у вас уйму времени
Нажмите, чтобы раскрыть...

ты бы хоть попробовал сначала, чтоли... а потом бы уже всякую ерунду говорил. Тебе нужно реализовать _четыре_ основные функции, три из которых тривиальны. о каких сложностях идет речь???

там так и сказано что "Ваш С компилятор может поддерживать 64-битные целые".
Нажмите, чтобы раскрыть...

Для тех кто в бронепоезде: а если ваш компилятор не поддерживает 64-битную арифметику -- используйте структуру LARGE_INTEGER.

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/winpr og/winprog/large_integer_str.asp

volodya · 20 мар 2005

Вопрос остаётся открытым, класс нужен. Наверно и не мне одному.

До тех пор, пока ты внятно не скажешь, чего тебе от этого класса нужно - так и будешь сам что-то кропать, пока не позеленеешь.

rgo · 21 мар 2005

а попробовать

typedef long long int int64;

У меня просто нету bc5 чтобы проверить, а в gcc это сработает.

OtD · 22 мар 2005

flankerx

Объясняю для тех кто в "бронепоезде":

1. Если нужен 64-х разрядный тип целых чисел, то он (класс) должен поддерживать все операции что и стандартный тип int или char, а если ты выучил только четыре операции которые придумал Аль Хоризми, то подучи ещё язык программирования .

2. Если до сих пор не въехал, привожу пример спецификации заголовочного файла, и то только для натуральных чисел:

Код (Text):

// :::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: :::::::

//

// КЛАСС: ODKNB64

//

// НАЗНАЧЕНИЕ:

// 1. Обеспечивает работу с целыми без знака 64-х битными числами.

class _ODK_DLL ODKNB64

{ public:

NB32 EK_1; // Меньная часть.

NB32 EK_2; // Большая часть.

_ODK_DLL// Для экспорта дружественных функций __declspec(dllexport).

// Конструкторы:

ODKNB64(){}

ODKNB64(NB32 dwArg):EK_1(dwArg), EK_2(0UL){}

ODKNB64(NB32 dwArg2, NB32 dwArg):EK_1(dwArg), EK_2(dwArg2){}

~ODKNB64(){}

// Функции операторы: + - * / % == != <= < >= > += -= *= /= %= << >> = [] () ->

// Манипулирование битами с присвоением операторы: |= ^= &= <<= >>=

// Побитовое ИЛИ |=:

ODKNB64& operator|=(kODKNB64& KUI64)

{EK_1|=KUI64.EK_1; EK_2|=KUI64.EK_2; return *this;}

ODKNB64& operator|=(NB32 dwArg) {EK_1|=dwArg; return *this;}

friend NB32& operator|=(NB32& dwArg, kODKNB64& KUI64)

{dwArg|=KUI64.EK_1; return dwArg;}

// Побитовое исключающее ИЛИ ^=:

ODKNB64& operator^=(kODKNB64& KUI64)

{EK_1^=KUI64.EK_1; EK_2^=KUI64.EK_2; return *this;}

ODKNB64& operator^=(NB32 dwArg) {EK_1^=dwArg; return *this;}

friend NB32& operator^=(NB32& dwArg, kODKNB64& KUI64)

{dwArg^=KUI64.EK_1; return dwArg;}

// Побитовое И &=:

ODKNB64& operator&=(kODKNB64& KUI64)

{EK_1&=KUI64.EK_1; EK_2&=KUI64.EK_2; return *this;}

ODKNB64& operator&=(NB32 dwArg) {EK_1&=dwArg; return *this;}

friend NB32& operator&=(NB32& dwArg, kODKNB64& KUI64)

{dwArg&=KUI64.EK_1; return dwArg;}

// Побитовый сдвиг влево <<=:

ODKNB64& __fastcall operator<<=(kODKNB64& KUI64);

ODKNB64& __fastcall operator<<=(NB32 dwArg);

friend NB32& __fastcall operator<<=(NB32& dwArg, kODKNB64& KUI64);

// Побитовый сдвиг вправо >>=:

ODKNB64& __fastcall operator>>=(kODKNB64& KUI64);

ODKNB64& __fastcall operator>>=(NB32 dwArg);

friend NB32& __fastcall operator>>=(NB32& dwArg, kODKNB64& KUI64);

// Манипулирование битами операторы: ~ | ^ & << >>

// Побитовое НЕТ ~:

ODKNB64 __fastcall operator~();

// Побитовое ИЛИ |:

ODKNB64 __fastcall operator|(kODKNB64& KUI64) const;

ODKNB64 __fastcall operator|(NB32 dwArg) const;

friend ODKNB64 __fastcall operator|(NB32 dwArg, kODKNB64& KUI64);

// Побитовое исключающее ИЛИ ^:

ODKNB64 __fastcall operator^(kODKNB64& KUI64) const;

ODKNB64 __fastcall operator^(NB32 dwArg) const;

friend ODKNB64 __fastcall operator^(NB32 dwArg, kODKNB64& KUI64);

// Побитовое И &:

ODKNB64 __fastcall operator&(kODKNB64& KUI64) const;

ODKNB64 __fastcall operator&(NB32 dwArg) const;

friend ODKNB64 __fastcall operator&(NB32 dwArg, kODKNB64& KUI64);

// Побитовый сдвиг влево <<:

ODKNB64 __fastcall operator<<(kODKNB64& KUI64) const;

ODKNB64 __fastcall operator<<(NB32 dwArg) const;

friend ODKNB64 __fastcall operator<<(NB32 dwArg, kODKNB64& KUI64);

// Побитовый сдвиг вправо >>:

ODKNB64 __fastcall operator>>(kODKNB64& KUI64) const;

ODKNB64 __fastcall operator>>(NB32 dwArg) const;

friend ODKNB64 __fastcall operator>>(NB32 dwArg, kODKNB64& KUI64);

// Логические операторы: ! || &&

// НЕ:

NB32 operator!() const {return !(EK_1|EK_2);}

// ИЛИ:

NB32 operator||(kODKNB64& KUI64) const

{return (EK_1|EK_2)||(KUI64.EK_1|KUI64.EK_2);}

NB32 operator||(NB32 dwArg) const {return (EK_1|EK_2)||dwArg;}

friend NB32 operator||(NB32 dwArg, kODKNB64& KUI64)

{return dwArg||(KUI64.EK_1|KUI64.EK_2);}

// И:

NB32 operator&&(kODKNB64& KUI64) const

{return (EK_1|EK_2)&&(KUI64.EK_1|KUI64.EK_2);}

NB32 operator&&(NB32 dwArg) const {return (EK_1|EK_2)&&dwArg;}

friend NB32 operator&&(NB32 dwArg, kODKNB64& KUI64)

{return dwArg&&(KUI64.EK_1|KUI64.EK_2);}

// Отношений операторы: == != <= < >= >

// Равно:

bool __fastcall operator==(kODKNB64& KUI64) const;

bool __fastcall operator==(NB32 dwArg) const;

friend bool __fastcall operator==(NB32 dwArg, kODKNB64& KUI64);

// Не равно:

bool __fastcall operator!=(kODKNB64& KUI64) const;

bool __fastcall operator!=(NB32 dwArg) const;

friend bool __fastcall operator!=(NB32 dwArg, kODKNB64& KUI64);

// Меньше или равно:

bool __fastcall operator<=(kODKNB64& KUI64) const;

bool __fastcall operator<=(NB32 dwArg) const;

friend bool __fastcall operator<=(NB32 dwArg, kODKNB64& KUI64);

// Меньше:

bool __fastcall operator<(kODKNB64& KUI64) const;

bool __fastcall operator<(NB32 dwArg) const;

friend bool __fastcall operator<(NB32 dwArg, kODKNB64& KUI64);

// Больше или равно:

bool __fastcall operator>=(kODKNB64& KUI64) const;

bool __fastcall operator>=(NB32 dwArg) const;

friend bool __fastcall operator>=(NB32 dwArg, kODKNB64& KUI64);

// Больше:

bool __fastcall operator>(kODKNB64& KUI64) const;

bool __fastcall operator>(NB32 dwArg) const;

friend bool __fastcall operator>(NB32 dwArg, kODKNB64& KUI64);

// Математические операторы: += + ++ -= - -- *= * /= / %= %

// Плюс: += + ++ // При переполнении результат максимальный:

// Сложение с присвоением результата: +=

ODKNB64& __fastcall operator+=(kODKNB64& KUI64);

ODKNB64& __fastcall operator+=(NB32 dwArg);

friend NB32& __fastcall operator+=(NB32& dwArg, kODKNB64& KU64P);

// Сложение: +

friend ODKNB64 __fastcall operator+(kODKNB64& KU64L, kODKNB64& KU64P);

friend ODKNB64 __fastcall operator+(kODKNB64& KU64L, NB32 dwArg);

friend ODKNB64 __fastcall operator+(NB32 dwArg, kODKNB64& KU64P);

// Пред и пост инкримент выполняются как пред инкремент: ++

friend ODKNB64& __fastcall operator++(ODKNB64& KU64L);

// Минус: -= - -- // При разнице меньше нуля результат = 0:

// Вычитание с присвоением результата: -=

ODKNB64& __fastcall operator-=(kODKNB64& KUI64);

ODKNB64& __fastcall operator-=(NB32 dwArg);

friend NB32& __fastcall operator-=(NB32& dwArg, kODKNB64& KU64P);

// Вычитание: -

friend ODKNB64 __fastcall operator-(kODKNB64& KU64L, kODKNB64& KU64P);

friend ODKNB64 __fastcall operator-(kODKNB64& KU64L, NB32 dwArg);

friend ODKNB64 __fastcall operator-(NB32 dwArg, kODKNB64& KU64P);

// Пред и пост декримент выполняются как пред декримент: --

friend ODKNB64& __fastcall operator--(ODKNB64& KUI64);

// Умножить: *= * // При переполнении результат максимальный:

// Умножение с присвоением результата: *=

ODKNB64& __fastcall operator*=(kODKNB64& KUI64);

ODKNB64& __fastcall operator*=(NB32 dwArg);

friend NB32& __fastcall operator*=(NB32& dwArg, kODKNB64& KU64P);

// Умножение: *

friend ODKNB64 __fastcall operator*(kODKNB64& KU64L, kODKNB64& KU64P);

friend ODKNB64 __fastcall operator*(kODKNB64& KU64L, NB32 dwArg);

friend ODKNB64 __fastcall operator*(NB32 dwArg, kODKNB64& KU64P);

// Разделить: /= / :

// Деление с присвоением результата: /=

ODKNB64& __fastcall operator/=(kODKNB64& KUI64);

ODKNB64& __fastcall operator/=(NB32 dwArg);

friend NB32& __fastcall operator/=(NB32& dwArg, kODKNB64& KU64P);

// Деление: /

friend ODKNB64 __fastcall operator/(kODKNB64& KU64L, kODKNB64& KU64P);

friend ODKNB64 __fastcall operator/(kODKNB64& KU64L, NB32 dwArg);

friend ODKNB64 __fastcall operator/(NB32 dwArg, kODKNB64& KU64P);

// Разделить по модулю: %= % :

// Деление по модулю с присвоением результата: %=

ODKNB64& __fastcall operator%=(kODKNB64& KUI64);

ODKNB64& __fastcall operator%=(NB32 dwArg);

friend NB32& __fastcall operator%=(NB32& dwArg, kODKNB64& KU64P);

// Деление по модулю: %

friend ODKNB64 __fastcall operator%(kODKNB64& KU64L, kODKNB64& KU64P);

friend ODKNB64 __fastcall operator%(kODKNB64& KU64L, NB32 dwArg);

friend ODKNB64 __fastcall operator%(NB32 dwArg, kODKNB64& KU64P);

// Присвоение:

ODKNB64& operator=(NB32 Arg) {EK_2=0UL; EK_1=(NB32)Arg; return *this;}

ODKNB64& operator=(ONB32 Arg)

{if(Arg==-1){EK_1=EK_2=-1;} else if(Arg<0){EK_1=EK_2=0UL;}

else {EK_1=Arg; EK_2=0UL;} return *this;}

ODKNB64& operator=(NB8 Arg) {return operator=((NB32)Arg);}

ODKNB64& operator=(ONB8 Arg) {return operator=((ONB32)Arg);}

ODKNB64& operator=(NB16 Arg) {return operator=((NB32)Arg);}

ODKNB64& operator=(ONB16 Arg) {return operator=((ONB32)Arg);}

ODKNB64& __fastcall operator=(const float& f32);

ODKNB64& __fastcall operator=(const double& fd64);

ODKNB64& __fastcall operator=(const long double& fld80);

// Начисление:

ODKNB64& operator()() {EK_1=0UL; EK_2=0UL; return *this;}

ODKNB64& operator()(NB32 dwArg) {EK_1=dwArg; EK_2=0UL; return *this;}

ODKNB64& operator()(NB32 dwArg2, NB32 dwArg)

{EK_1=dwArg; EK_2=dwArg2; return *this;}

// Для преобразования к типу unsigned int:

operator unsigned int() const {return EK_1;}

#ifdef __ODDEF32_H

// Для преобразования в логическое выражение типа int:

operator DANET() const {return (EK_1|EK_2);}

#elif _WINDEF_

// Для преобразования в логическое выражение типа int:

operator BOOL() const {return (EK_1|EK_2);}

#else

// Для преобразования к типу int:

operator int() const {return EK_1;}

#endif

// Для преобразования к типу логическое выражение в 1 байт:

operator bool() const {return (EK_1|EK_2);}

// Для преобразования к типу unsigned long:

operator NB32() const {return EK_1;}

// Для преобразования к типу long:

operator long() const {return EK_1;}

// Для преобразования к типу NB16:

operator NB16() const {return EK_1;}

// Для преобразования к типу short:

operator short() const {return EK_1;}

// Для преобразования к типу unsigned char:

operator unsigned char() const {return EK_1;}

// Для преобразования к типу char:

operator char() const {return EK_1;}

// Для преобразования к типу const char*:

//operator const char*() const {return EK_1;}

// Для преобразования к типу float. Загружает в FPU.387.:

__fastcall operator float() const;

// Для преобразования к типу double. Загружает в FPU.387.:

__fastcall operator double() const;

// Для преобразования к типу long double. Загружает в FPU.387.:

__fastcall operator long double() const;

// Функции: ()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()()

// Вставить строку с конечным нулём формата ASCII текущего значения класса:

// VsStr() формирует строку различных систем счисления.

// Параметры:

// szByfer - Приёмный буфер для строки.

// dwForm - Форма строки:

// Младший байт №1 - указывает размер групп через делитель байт №2.

// Например: значение 3 формирует число 1234567890 как

// число 1 234 567 890.

// Байт №2 - байт делитель групп. При 0 пробел.

// Байт №3 - размер нулевых заполнителей.

// Например: значение 10 формирует число 12345 как

// число 0 000 012 345, а число 5 как 0 000 000 005.

// lSisSch - система счисления 2 значит двоичная, 8 - восьмеричная,

// 10 - десятеричная, 16 - шестнадцатиричная.

// Возврат: Удачно - длина строки в байтах без учёта конечного нуля.

// Провал - 0.

ONB32 __fastcall VsStr(iNB8 szByfer, NB32 dwForm, long lSisSch);

// VsStr10() формирует строку десятеричной системы счисления.

// Макро определения:

#define ODKNB64_STR10_BYFER 44 // Необходимый размер буфера.

// Параметры: szByfer - Приёмный буфер для строки. Размер не менее 44 байта.

// dwForm - Форма строки: Те же что и у VsStr().

ONB32 VsStr10(iNB8 szByfer, NB32 dwForm=3)

{return VsStr(szByfer, dwForm, 10);}

// VsStr2() формирует строку двоичной системы счисления.

// Макро определения:

#define ODKNB64_STR2_BYFER 132 // Необходимый размер буфера.

// Параметры: szByfer - Приёмный буфер для строки. Размер не менее 132 байта.

// dwForm - Форма строки: Те же что и у VsStr().

ONB32 VsStr2(iNB8 szByfer, NB32 dwForm=4)

{return VsStr(szByfer, dwForm, 2);}

// VsStr8() формирует строку восьмеричной системы счисления.

// Макро определения:

#define ODKNB64_STR8_BYFER 48 // Необходимый размер буфера.

// Параметры: szByfer - Приёмный буфер для строки. Размер не менее 48 байт.

// dwForm - Форма строки: Те же что и у VsStr().

ONB32 VsStr8(iNB8 szByfer, NB32 dwForm=3)

{return VsStr(szByfer, dwForm, 8);}

// VsStr16() формирует строку шестнадцатиричной системы счисления.

// Макро определения:

#define ODKNB64_STR16_BYFER 36 // Необходимый размер буфера.

// Параметры: szByfer - Приёмный буфер для строки. Размер не менее 36 байт.

// dwForm - Форма строки: Те же что и у VsStr().

// Байт №4 - добавление к базовым буквам "ABCDEF".

// Например: значение 32 формирует буквы "ABCDEF" как

// буквы "abcdef".

ONB32 VsStr16(iNB8 szByfer, NB32 dwForm=2)

{return VsStr(szByfer, dwForm, 16);}

// Взять строку с конечным нулём формата ASCII для установки значения класса:

// VzStr() формирует значение из строки различных систем счисления.

// Параметры: szStr - Строка с конечным dwForm байт №3.

// Формат строки десятеричной системы счисления: 98...210.

// Количество значащих цифр не более 20.

// Формат строки шестнадцатиричной системы счисления: 0xFE...210.

// Количество значащих цифр не более 16.

// Формат строки восьмеричной системы счисления: 0o76...210.

// Количество значащих цифр не более 22.

// Формат строки двоичной системы счисления: 0b10.

// Количество значащих цифр не более 64.

// dwForm - Форма строки:

// Младший байт №1 - указывает размер строки, может быть 0.

// Байт №2 - байт делитель групп. При 0 пробел.

// Байт №3 - байт окончания строки.

// Возврат: Удачно - 1.

// Провал - 0.

ONB32 __fastcall VzStr(kiNB8 szStr, NB32 dwForm=0);

};

volodya

Ладно, Володя, объясняю внятно: мне нужен класс для управления файлами больших размеров, как например класс по управлению файлами от Borland TFile, только этот класс не работает с большими числами.

Если кто знает где есть похожий класс, только для больших 64-х битных аргументов, сообщите пожалуйста.

Привожу спецификацию TFile, нужен похожий:

Syntax

class TFile

Header File

file.h

Description

The TFile class encapsulates standard file characteristics and operations.

Constructors

TFile::TFile

Public Data Members

FileNull

File Flags

Member Functions

Close

Flush

GetHandle

GetStatus

IsOpen

Length

LockRange

Open

Position

Read

Remove

Rename

Seek

SeekToBegin

SeekToEnd

SetStatus

UnlockRange

Write

rgo

"typedef long long int int64;"

Даже если такой абсурд и сработает в каком-то компиляторе , то кто всю логику сделает.

P.S. Для ВСЕХ.

Ребята, я всех уважаю и понимаю что каждый находится на своём уровне познания, и по этому прошу не показывать своё невежество.

Все мы (программисты) делаем одно большое дело - Пытаемся упорядочить наш мир познаного. По этому давайте относиться с уважением к любому уровню знаний (не уму, прошу не путать).

Всем удачи. А класс для файлов нужен.

volodya · 22 мар 2005

http://www.undu.com/Articles/980916a.html

s0larian · 23 мар 2005

>> "typedef long long int int64;"

> Даже если такой абсурд и сработает в каком-то

> компиляторе , то кто всю логику сделает.

Если это абсурд, то возьми какой-нить школьный курс по С и Win32 програмированию!

Объясняю популярно, то есть для твоего "уровня познания":

gcc/g++: имеет свой родной 64 bit тип "long long"

VC6/VC7: предоставляют подобный тип под именем "__int64"

И оба компилятора генерируют весь код, необходимый для того что бы эти типы вели себя так же как и остальные встроенные типы. Замечу, что в зависимости от taget CPU, компиллеры будут герерировать разный код - то есть на для Pentium кода будет больше, и он будет медленнее чем для P4. Но с точки зрения програмиста, всего этого не видно.

Ну теперь тебе понятно?

Вот что я использую в VC7.1:

typedef unsigned __int64 uint64;

typedef unsigned long uint32;

typedef unsigned short uint16;

s0larian · 23 мар 2005

Теперь по поводу files: RTFM!!!!

From MSDN:

SetFilePointer() - moves the file pointer of an open file.

DWORD SetFilePointer(

HANDLE hFile,

LONG lDistanceToMove,

PLONG lpDistanceToMoveHigh,

DWORD dwMoveMethod

);

hFile

[in] Handle to the file whose file pointer is to be moved. The file handle must have been created with the GENERIC_READ or GENERIC_WRITE access right. For more information, see File Security and Access Rights.

lDistanceToMove

[in] Low-order 32 bits of a signed value that specifies the number of bytes to move the file pointer. If lpDistanceToMoveHigh is not NULL, lpDistanceToMoveHigh and lDistanceToMove form a single 64-bit signed value that specifies the distance to move. If lpDistanceToMoveHigh is NULL, lDistanceToMove is a 32-bit signed value. A positive value for lDistanceToMove moves the file pointer forward in the file, and a negative value moves the file pointer backward.

lpDistanceToMoveHigh

[in] Pointer to the high-order 32 bits of the signed 64-bit distance to move. If you do not need the high-order 32 bits, this pointer must be set to NULL. When non-NULL, this parameter also receives the high-order DWORD of the new value of the file pointer. For more information, see the Remarks section later in this topic.

dwMoveMethod

[in] Starting point for the file pointer move. This parameter can be one of the following values.

Example

// Try to move hFile's file pointer some huge distance.

dwPtrLow = SetFilePointer (hFile, lDistLow, & lDistHigh, FILE_BEGIN) ;

P.S. также можно вызвать SetFilePointerEx() которая берёт __int64/LARGE_INTEGER.

P.P.S. то есть, пишешь минимальный TCoolFile class с обычными Open(), Close(), Read(), Write() и двумя Seek():

bool Seek(origin, uint32 distance);

bool Seek64(origin, uint64 distance);

OtD · 23 мар 2005

Для volodya:

Спасибо, но не то.

Нужен класс С++, а там Паскаль.

Асинхронности нет и другие свойства Windows проигнорированы.

Вопрос остаётся в силе. Всем заранее спасибо.

volodya · 23 мар 2005

Смысла я особого в этом классе как не видел, так и не вижу

Все это, разумеется, достигается использованием WinAPI + LARGE_INTEGER/__int64 - и никто не умирает. А тут - класс писать, причем с детской функциональностью, насколько я понял из твоего предложения выше :-/ Ладно люди, пишите класс, я выбыл.

Войти или зарегистрироваться

Где Взять класс С++ для работы с файлами более 2Гб.

OtD Member

volodya wasm.ru

flankerx New Member

OtD Member

flankerx New Member

amitophia New Member

OtD Member

volodya wasm.ru

AsmGuru62 Member

OtD Member

OtD Member

flankerx New Member

volodya wasm.ru

rgo New Member

OtD Member

volodya wasm.ru

s0larian New Member

s0larian New Member

OtD Member

volodya wasm.ru

Войти или зарегистрироваться

Где Взять класс С++ для работы с файлами более 2Гб.

OtD Member

volodya wasm.ru

flankerx New Member

OtD Member

flankerx New Member

amitophia New Member

OtD Member

volodya wasm.ru

AsmGuru62 Member

OtD Member

OtD Member

flankerx New Member

volodya wasm.ru

rgo New Member

OtD Member

volodya wasm.ru

s0larian New Member

s0larian New Member

OtD Member

volodya wasm.ru

Быстрый поиск