Форум программистов [Powered by Invision Power Board]

Версия для печати темы
Нажмите сюда для просмотра этой темы в оригинальном формате

Форум программистов > Центр помощи > [C++] Классы ресурсоёмких объектов

Автор: Mcicool 3.11.2006, 00:51

Задача:

   Определить класс "набор слов" с закрытыми компонентами:
число слов и динамический массив с элементами типа string,
каждый из которых представляет отдельное слово.
(Слово - последовательность русских или английских букв -
никаких других символов в слове не должно быть.)
   Ввести все методы, присущие классу ресурсоемких объектов.
Предусмотреть конструктор для формирования объекта класса
на основе строки (string), содержащей некоторый текст.
Предусмотреть в классе перегрузку операций для ввода-вывода
(<<, >>) и ,если потребуется, любые средства, необходимые
для решения основной задачи.

   В основной программе читать по строкам текстовый файл (имя
файла ввести с клавиатуры). Для каждой прочитанной строки
формировать объект класса "набор слов". Анализируя создаваемые
объекты, вывести объект (набор слов) с максимальным количеством
слов и последний из объектов, количество слов в котором равно
заданному с клавиатуры числу.

Автор: Oleg_Ci 3.11.2006, 16:34

Что-то на подобие этого ?

Код


#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;

class Word
{
private:
    vector<string> line; // динамический массив слов
public:
    Word() {};
    Word( string & str );
    friend istream & operator>>( istream & in, Word & w );
    friend ostream & operator<<( ostream & out, Word & w );
    void erase()        { line.erase(line.begin(), line.end()); }
};
typedef vector<string>::iterator iter;
istream & operator>>( istream & in, Word & w ){
    string temp;
    in >> temp;
    w.line.push_back( temp );
    return in;
}
ostream & operator<<( ostream & out, Word & w ){
    for( iter ptr = w.line.begin(); ptr != w.line.end(); ptr++ )
        out << *ptr << "\n";
    return out;
}

//_________ MAIN_________________
int main(int argc, char *argv[])
{ 
    ifstream file("text.txt");
    if( !file.is_open()) return 1;
    Word w;
    while( file >> w );
    cout << w;
    
    getchar();
    return 0;
}

Автор: Mcicool 3.11.2006, 17:35

Ты не мог бы камменты разместить. Спасибо ))
5 ошибок:

C:\Documents and Settings\Mcicool\Ðàáî÷èé ñòîë\Cpp\prog2.cpp(22) : error C2248: 'line' : cannot access private member declared in class 'Word'
        C:\Documents and Settings\Mcicool\Ðàáî÷èé ñòîë\Cpp\prog2.cpp(10) : see declaration of 'line'
C:\Documents and Settings\Mcicool\Ðàáî÷èé ñòîë\Cpp\prog2.cpp(26) : error C2248: 'line' : cannot access private member declared in class 'Word'
        C:\Documents and Settings\Mcicool\Ðàáî÷èé ñòîë\Cpp\prog2.cpp(10) : see declaration of 'line'
C:\Documents and Settings\Mcicool\Ðàáî÷èé ñòîë\Cpp\prog2.cpp(26) : error C2248: 'line' : cannot access private member declared in class 'Word'
        C:\Documents and Settings\Mcicool\Ðàáî÷èé ñòîë\Cpp\prog2.cpp(10) : see declaration of 'line'
C:\Documents and Settings\Mcicool\Ðàáî÷èé ñòîë\Cpp\prog2.cpp(37) : error C2593: 'operator >>' is ambiguous
C:\Documents and Settings\Mcicool\Ðàáî÷èé ñòîë\Cpp\prog2.cpp(37) : fatal error C1903: unable to recover from previous error(s); stopping compilation
Error executing cl.exe.

Автор: Oleg_Ci 3.11.2006, 19:35

А компилятор какой у вас ?
Я проверял на WS2003 и Borland C++ Builder6, Dev-C++ у меня без ошибок...

Код


#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
using namespace std;

class Word // класс "набор слов"
{
private:
    vector<string> line; // динамический массив слов
public:
    Word() {}; // конструктор
    Word( string & str ); // конструктор принимающий строку
    friend istream & operator>>( istream & in, Word & w ); // ввод слов из потока
    friend ostream & operator<<( ostream & out, Word & w ); // вывод слов в поток
    void erase()    { line.erase(line.begin(), line.end()); } // удаление всех слов
};
typedef vector<string>::iterator iter; // итератор
istream & operator>>( istream & in, Word & w ){
    string temp;
    in >> temp; // читаем строку в string
    w.line.push_back( temp ); // заносим эту строку в массив
    return in;
}
ostream & operator<<( ostream & out, Word & w ){
    for( iter ptr = w.line.begin(); ptr != w.line.end(); ptr++ )
        out << *ptr << "\n"; // выводим все слова из массива в поток
    return out;
}
Word::Word( string & str ){
    stringstream out;
    out << str;
    string s;
    while( out >> s )
        line.push_back( s );
}
//_________ MAIN_________________
int main(int argc, char *argv[])
{ 
    ifstream file("text.txt"); // открываем файл
    if( !file.is_open()) return 1; // если не открылся то выходим из программы
    Word w; // класс - набор слов
    while( file >> w ); // копируем все слова в класс "набор слов"
    cout << w << "\n\n\n"; // выодим все слова из класса "набор слов" на консоль
    
    Word s(string("asd das afa sf sa gs gfdsg dsf")); // новый класс - набор
    cout << s; // вывод нового класса

    getchar(); // пауза
    return 0;
}

Автор: Mcicool 3.11.2006, 23:19

У меня Visual C++. Пишет те же ошибки.
Кстати, я вот честно не понимаю, чем компиляторы отличаются?

Добавлено @ 23:21
Кстати. А зачем используется итератор? Я читал, но никак не могу понять, что это по-русски значит.

Автор: Oleg_Ci 6.11.2006, 14:29

Насочинял ещё чего-то

Код


// Файл Word.h___________________________________________
#ifndef Word_h
#define Word_h

#include <iostream>
#include <string>
#include <cctype>
using std::string;
using std::istream;
using std::ostream;

typedef string::size_type position;
class Word
{
private:
    string * array; // динамический массив слов
    size_t buffer; // реальное количество выделенной памяти под массив
    size_t count; // количество слов
    string Substr( const string & str, position & pos ) const; // выделение слова из строки
    void add_memory( const size_t size ); // увеличить память

public:
    static size_t add_size; // размер выделяемой памяти за один раз
    static string end_str; // символ разделитель выводимый при выводе слов в поток ("\n")

    Word() : array(NULL), count(0), buffer(0) {}; // кнструктор по умолчанию
    Word( const string & str ); // кoнструктор
    Word( const char * str );
    Word( const Word & w ); // конструктор копирования
    virtual ~Word(); // деструктор

    Word & operator=( const Word &w ); // оператор присвоения
    Word operator+( const Word & w ); // складывание массивов слов
    Word operator+( const string & str ); // прибавление слов тип - string
    Word operator+( const char * str ); // добавление слов тип - char*
    Word & operator+=( const Word & w );
    Word & operator+=( const string & str );
    Word & operator+=( const char * str );
    string & operator[](  const size_t pos )const; // получение слова по индексу

    friend istream & operator>>( istream & in, Word & w ); // чтение слов из потока
    friend ostream & operator<<( ostream & out, const Word & w ); // вывод слов в поток

    /* erase - удаление слов c позиции - begin, количеством - size
    нумерация позиций с нуля ( для begin ),
    если size=1, удаляется один слово из позиции begin
    если size=0, удаляются все слова от begin до конца массива */
    void erase( size_t begin = 0, size_t size = 1 ); // поумолчанию удаляются все слова из массива
    size_t size() { return count; } // количество слов в массиве
    const size_t size()const { return count; }
};

#endif // Word_h

Код


// Файл Word.cpp __________________________________________
#include "Word.h"
#include <string.h>
// для сокращения количества перераспределений памяти add_size увеличить.
size_t Word::add_size = 10; // выделяем память за раз для 10 слов.
string Word::end_str = "\n"; // символ разделитель 
////////// конструктры /////////////////////////////
Word::Word( const string & str ){
    buffer = count = 0;
    array = NULL;
    *this += str;
}
/////////////////////////
Word::Word( const Word & w ){
    buffer = count = 0;
    array = NULL;
    *this = w;
}
////////////////////////
Word::Word( const char * str ){
    buffer = count = 0;
    array = NULL;
    *this += str;
}
////////////////////// деструктор ///////////////
Word::~Word(){
    if( array ) delete [] array;
    buffer = count = 0;
    array = NULL;
}
////////// операторы ///////////////////////////////
Word & Word::operator=( const Word &w ){
    if( this == &w ) return *this;
    this->~Word();
    count = w.count;
    add_memory( count );
    for( size_t i=0; i<count; i++ )
        array[i] = w.array[i];
    return *this;
}
///////////////////////////////////
Word Word::operator+( const string & str ){
    Word w;
    position pos = 0;
    string s;
    while( 1 ){
        s = Substr( str, pos );
        if( pos == string::npos ) break;
        w.count++;
        w.add_memory( w.count );
        w.array[w.count-1] = s;
    }
    return w;
}
//////////////////////////////////
Word Word::operator+( const char * str ){
    return Word::operator +( string(str));
}
/////////////////////////////////
Word & Word::operator+=( const Word & w ){
    size_t x = w.count;
    add_memory( x );
    for( size_t i=0; i<x; i++ ){
        array[count++] = w.array[i];
    }
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const string & str ){
    position pos = 0;
    string s;
    while( 1 ){
        s = Substr( str, pos );
        if( pos == string::npos ) break;
        count++;
        add_memory( count );
        array[count-1] = s;
    }
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const char * str ){
    *this += string( str );
    return *this;
}
//////////////////////////////////
Word Word::operator+( const Word & w ){
    Word wd;
    for( size_t i=0; i<w.count; i++ )
        wd = wd + w.array[i];
    return wd;
}
//////////////////////////////////
istream & operator>>( istream & in, Word & w ){
    string str;
    getline( in, str ); // читаем из потока строку
    w += str; // записываем слова в массив
    return in;
}
//////////////////////////////////
ostream & operator<<( ostream & out,const Word & w ){
    for( size_t i=0; i<w.size(); i++ )
        out << w[i] << Word::end_str; // выводим строки в поток с символом разделителем
    return out;
}
////////////////////////////////////
string & Word::operator[](  const size_t pos )const{
    return array[pos]; // возвращаем слово по индексу в массиве
}
/////////// функции ////////////////////////////////////
string Word::Substr( const string & str, position & pos )const{
    position begin = pos; // начало слова
    for(; str[begin] && !isalpha( str[begin] ); begin++ );
    for( pos = begin; str[begin] && isalpha( str[pos] ); pos++ ); // конец слова - pos
    if( pos != begin ) return str.substr( begin, pos-begin );
    pos = string::npos;
    return string();
}
//////////////////////////////////
void Word::add_memory( const size_t size ){
    if ( buffer > count + size )  return; // если буфер памяти не заполнен

    size_t x = buffer; // количество элементов в старом буфере
    buffer += add_size * int( size/add_size +1 ); // увеличиваем буфер
    string * ptr = new string[buffer]; // выделяем новую память

    if( array ){ // если выделяем не в первый раз
        memcpy( ptr, array, x*sizeof(string));    // копируем строки из старого буфера в новый
        delete [] array; // удаляем старый буфер
    }
    array = ptr;
}
///////////////////////////////////
void Word::erase( size_t begin, size_t size ){
    Word w;
    for( size_t i = 0; i < begin && i < count; i++ )
        w += this->array[i];
    for( size_t i = begin + size; i < count; i++ )
        w += this->array[i];
    *this = w;
}
// end class  Word _______________________________

Код


// Файл main.cpp ________________________________________-
#include <iostream>
#include <fstream>
#include "Word.h"
using namespace std;

//_________ MAIN_________________
int main(int argc, char *argv[])
{ 
    // проверяем функции класса Word:
    Word w("aaa   bbb"); // конструктор принимающий строку char*
    w += "ccc"; // добавление слова char*
    w += w; // добавление слов из массива слов
    w.erase( 4 ); // удаление слова
    w.erase( 3, 2 ); // удаление двух слов
    cout << w; // вывод слов в поток ( консоль )
    cout << "\n\nEnter string: "; // "Введите слова"
    cin >> w; // ввод слов из потока
    Word::end_str = ", "; // символ разделитель для вывода
    cout << "\n" << w << "\n\n";
    Word::end_str = "\n";
    cout << Word::end_str << w;
    
    // чтение строк из файла
    string str;
    cout << "\n\nEnter filename : ";
    cin >> str;
    ifstream file(str); // открываем файл
    if( !file.is_open()){
        cout << "\n\nError open file...";
        getchar();
        getchar();
        return 1;
    }
    while( !file.eof()){
        file >> w; // считываем слова из файла
    }
    cout << w; // выводим их на косоль
    getchar(); // пауза
    getchar();
    return 0;
}
//________ END MAIN ______________

Автор: Mcicool 6.11.2006, 17:31

Обалдеть, буду теперь сидеть разбираться. Спасибо!

Автор: Mcicool 7.11.2006, 18:21

Я так и не смог проверить работоспособность прораммы (
Как это все в один файл засунуть?

Автор: Oleg_Ci 7.11.2006, 19:11

Mcicool, смотри внимательней, могут-быть ошибки smile

Код


/ Файл main.cpp ________________________________________
#include <iostream>
#include <string>
#include <cctype>
#include <fstream>
using namespace std;

typedef string::size_type position;
class Word
{
private:
    
    string * array; // динамический массив слов
    size_t buffer; // реальное количество выделенной памяти под массив
    size_t count; // количество слов
    string Substr( const string & str, position & pos ) const; // выделение слова из строки
    void add_memory( const size_t size ); // увеличить память

public:
    size_t add_size; // размер выделяемой памяти за один раз
    string end_str; // символ разделитель выводимый при выводе слов в поток ("\n")

    Word() : array(NULL), count(0), buffer(0), add_size(10), end_str("\n") {}; // кнструктор по умолчанию
    Word( const string & str ); // кoнструктор
    Word( const char * str );
    Word( const Word & w ); // конструктор копирования
    virtual ~Word(); // деструктор

    Word & operator=( const Word &w ); // оператор присвоения
    Word operator+( const Word & w ); // складывание массивов слов
    Word operator+( const string & str ); // прибавление слов тип - string
    Word operator+( const char * str ); // добавление слов тип - char*
    Word & operator+=( const Word & w );
    Word & operator+=( const string & str );
    Word & operator+=( const char * str );
    string & operator[](  const size_t pos )const; // получение слова по индексу

    friend istream & operator>>( istream & in, Word & w ); // чтение слов из потока
    friend ostream & operator<<( ostream & out, const Word & w ); // вывод слов в поток

    /* erase - удаление слов c позиции - begin, количеством - size
    нумерация позиций с нуля ( для begin ),
    если size=1, удаляется один слово из позиции begin
    если size=0, удаляются все слова от begin до конца массива */
    void erase( size_t begin = 0, size_t size = 1 ); // поумолчанию удаляются все слова из массива
    size_t size() { return count; } // количество слов в массиве
    const size_t size()const { return count; }
};


////////// конструктры /////////////////////////////
Word::Word( const string & str ){
    // для сокращения количества перераспределений памяти add_size увеличить.
    add_size = 10; // выделяем память за раз для 10 слов.
    end_str = "\n"; // символ разделитель 
    buffer = count = 0;
    array = NULL;
    *this += str;
}
/////////////////////////
Word::Word( const Word & w ){
    add_size = 10;
    end_str = "\n";
    buffer = count = 0;
    array = NULL;
    *this = w;
}
////////////////////////
Word::Word( const char * str ){
    add_size = 10;
    end_str = "\n";
    buffer = count = 0;
    array = NULL;
    *this += str;
}
////////////////////// деструктор ///////////////
Word::~Word(){
    if( array ) delete [] array;
    buffer = count = 0;
    array = NULL;
}
////////// операторы ///////////////////////////////
Word & Word::operator=( const Word &w ){
    if( this == &w ) return *this;
    this->~Word();
    count = w.count;
    add_memory( count );
    for( size_t i=0; i<count; i++ )
        array[i] = w.array[i];
    return *this;
}
///////////////////////////////////
Word Word::operator+( const string & str ){
    Word w;
    position pos = 0;
    string s;
    while( 1 ){
        s = Substr( str, pos );
        if( pos == string::npos ) break;
        w.count++;
        w.add_memory( w.count );
        w.array[w.count-1] = s;
    }
    return w;
}
//////////////////////////////////
Word Word::operator+( const char * str ){
    return Word::operator +( string(str));
}
/////////////////////////////////
Word & Word::operator+=( const Word & w ){
    size_t x = w.count;
    add_memory( x );
    for( size_t i=0; i<x; i++ ){
        array[count++] = w.array[i];
    }
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const string & str ){
    position pos = 0;
    string s;
    while( 1 ){
        s = Substr( str, pos );
        if( pos == string::npos ) break;
        count++;
        add_memory( count );
        array[count-1] = s;
    }
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const char * str ){
    *this += string( str );
    return *this;
}
//////////////////////////////////
Word Word::operator+( const Word & w ){
    Word wd;
    for( size_t i=0; i<w.count; i++ )
        wd = wd + w.array[i];
    return wd;
}
//////////////////////////////////
istream & operator>>( istream & in, Word & w ){
    string str;
    getline( in, str ); // читаем из потока строку
    w += str; // записываем слова в массив
    return in;
}
//////////////////////////////////
ostream & operator<<( ostream & out,const Word & w ){
    for( size_t i=0; i<w.size(); i++ )
        out << w[i] << w.end_str; // выводим строки в поток с символом разделителем
    return out;
}
////////////////////////////////////
string & Word::operator[](  const size_t pos )const{
    return array[pos]; // возвращаем слово по индексу в массиве
}
/////////// функции ////////////////////////////////////
string Word::Substr( const string & str, position & pos )const{
    position begin = pos; // начало слова
    for(; str[begin] && !isalpha( str[begin] ); begin++ );
    for( pos = begin; str[begin] && isalpha( str[pos] ); pos++ ); // конец слова - pos
    if( pos != begin ) return str.substr( begin, pos-begin );
    pos = string::npos;
    return string();
}
//////////////////////////////////
void Word::add_memory( const size_t size ){
    if ( buffer > count + size )  return; // если буфер памяти не заполнен

    size_t x = buffer; // количество элементов в старом буфере
    buffer += add_size * int( size/add_size +1 ); // увеличиваем буфер
    string * ptr = new string[buffer]; // выделяем новую память

    if( array ){ // если выделяем не в первый раз
        memcpy( ptr, array, x*sizeof(string));    // копируем строки из старого буфера в новый
        delete [] array; // удаляем старый буфер
    }
    array = ptr;
}
///////////////////////////////////
void Word::erase( size_t begin, size_t size ){
    Word w;
    for( size_t i = 0; i < begin && i < count; i++ )
        w += this->array[i];
    for( size_t i = begin + size; i < count; i++ )
        w += this->array[i];
    *this = w;
}
///////////////////////////////////////////
//_________ MAIN_________________
int main(int argc, char *argv[])
{ 
    // проверяем функции класса Word:
    Word w("aaa   bbb"); // конструктор принимающий строку char*
    w += "ccc"; // добавление слова char*
    w += w; // добавление слов из массива слов
    w.erase( 4 ); // удаление слова
    w.erase( 3, 2 ); // удаление двух слов
    cout << w; // вывод слов в поток ( консоль )
    cout << "\n\nEnter string: "; // "Введите слова"
    cin >> w; // ввод слов из потока
    w.end_str = ", "; // символ разделитель для вывода
    cout << "\n" << w << "\n\n";
    w.end_str = "\n";
    cout << w.end_str << w;
    
    // чтение строк из файла
    string str;
    cout << "\n\nEnter filename : ";
    cin >> str;
    ifstream file;
    file.open( str.c_str());// открываем файл
    if( !file.is_open()){
        cout << "\n\nError open file...";
        getchar();
        getchar();
        return 1;
    }
    while( !file.eof()){
        file >> w; // считываем слова из файла
    }
    cout << w; // выводим их на косоль
    getchar(); // пауза
    getchar();
    return 0;
}

Автор: Mcicool 7.11.2006, 19:30

14 ошибок )))
error C2143: syntax error : missing ';' before '/'
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(1) : error C2018: unknown character '0xd4'
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(1) : error C2018: unknown character '0xe0'
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(1) : error C2018: unknown character '0xe9'
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(1) : error C2018: unknown character '0xeb'
c:\program files\microsoft visual studio\vc98\include\errno.h(29) : error C2143: syntax error : missing ';' before '{'
c:\program files\microsoft visual studio\vc98\include\errno.h(29) : error C2447: missing function header (old-style formal list?)
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(189) : error C2374: 'i' : redefinition; multiple initialization
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(187) : see declaration of 'i'
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(203) : error C2593: 'operator <<' is ambiguous
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(205) : error C2593: 'operator >>' is ambiguous
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(207) : error C2593: 'operator <<' is ambiguous
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(209) : error C2593: 'operator <<' is ambiguous
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(224) : error C2593: 'operator >>' is ambiguous
c:\documents and settings\mcicool\ðàáî÷èé ñòîë\cpp\prog8\main.cpp(226) : error C2593: 'operator <<' is ambiguous
Error executing cl.exe.

main.obj - 14 error(s), 0 warning(s)

Автор: Oleg_Ci 8.11.2006, 06:57

Ну тогда я тебе не помогу...
Может только подключаемые файлы изменить попробывать

Код


#include <iostream.h>
...

Автор: Mcicool 8.11.2006, 13:36

А ты сам проверял? У тебя работает?
Че она вообще делает ? smile

Автор: Oleg_Ci 8.11.2006, 17:06

Ну конечно всё работает smile

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

Цитата(Mcicool @ 8.11.2006, 17:36

)

Че она вообще делает ?

ну ведь прокоментировал немного, вроде должно понятно быть.
Есть класс который содержит массив слов.
Умеет добавлять слова из строк char*, string, и из себе подобных массивов.
Умеет читать слова с консоли и из файла, и тудаже записывать.
Удалять слова тоже умеет.
Кстати работает только в DOS кодировке... т.е. с русскими буквами написанными в windows проблемы будут.

smile

Прога версия№ 3 :

Код


#include <iostream>
#include <string>
#include <cctype>
#include <fstream>
using namespace std;


class Word{
private:

    typedef string::size_type position;
    string * array; // динамический массив слов
    size_t count; // количество слов
    string Substr( const string & str, position & pos ) const; // выделение слова из строки
    void add_memory( const size_t size = 1 ); // увеличить память ( по умолчанию на 1 сторку )
    void _null(); // "обнулятор"

public:
    string end_str; // символ разделитель выводимый при выводе слов в поток ("\n")

    Word() : array(NULL), count(0), end_str("\n") {}; // кнструктор по умолчанию
    Word( const string & str ); // кoнструктор
    Word( const char * str );
    Word( const Word & w ); // конструктор копирования
    virtual ~Word(); // деструктор

    Word & operator=( const Word &w ); // оператор присвоения
    Word & operator+=( const Word & w );
    Word & operator+=( const string & str );
    Word & operator+=( const char * str );
    string & operator[](  const size_t pos )const; // получение слова по индексу

    friend istream & operator>>( istream & in, Word & w ); // чтение слов из потока
    friend ostream & operator<<( ostream & out, const Word & w ); // вывод слов в поток

    /* erase - удаление слов c позиции - begin, количеством - size
    нумерация позиций с нуля ( для begin ),
    если size=1, удаляется один слово из позиции begin
    если size=0, удаляются все слова от begin до конца массива */
    void erase( size_t begin = 0, size_t size = 1 ); // поумолчанию удаляются все слова из массива
    const size_t size()const { return count; }// количество слов в массиве
};


////////// конструктры /////////////////////////////
Word::Word( const string & str ){
    _null();
    *this += str;
}
/////////////////////////
Word::Word( const Word & w ){
    _null();
    *this = w;
}
////////////////////////
Word::Word( const char * str ){
    _null();
    *this += str;
}
////////////////////// деструктор ///////////////
Word::~Word(){
    if( array ) delete [] array;
    _null();
}
////////// операторы ///////////////////////////////
Word & Word::operator=( const Word &w ){
    if( this == &w ) return *this;
    this->~Word();
    add_memory( w.count );
    for( size_t i=0; i<count; i++ )
        array[i] = w.array[i];
    return *this;
}
/////////////////////////////////
Word & Word::operator+=( const Word & w ){
    size_t x = w.count;
    add_memory( x );
    for( size_t i=0; i<x; i++ ){
        array[count -x ] = w.array[i];
    }
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const string & str ){
    position pos = 0;
    string s;
    while( 1 ){
        s = Substr( str, pos );
        if( pos == string::npos ) break;
        add_memory();
        array[count-1] = s;
    }
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const char * str ){
    return *this += string( str );
}
//////////////////////////////////
istream & operator>>( istream & in, Word & w ){
    string str;
    getline( in, str ); // читаем из потока строку
    w += str; // записываем слова в массив
    return in;
}
//////////////////////////////////
ostream & operator<<( ostream & out,const Word & w ){
    for( size_t i=0; i<w.size(); i++ )
        out << w[i] << w.end_str; // выводим строки в поток с символом разделителем
    return out;
}
////////////////////////////////////
string & Word::operator[](  const size_t pos )const{
    return array[pos]; // возвращаем слово по индексу в массиве
}
/////////// функции ////////////////////////////////////
string Word::Substr( const string & str, position & pos )const{
    position begin = pos; // начало слова
    for(; str[begin] && !isalpha( str[begin] ); begin++ );
    for( pos = begin; str[begin] && isalpha( str[pos] ); pos++ ); // конец слова - pos
    if( pos != begin ) return str.substr( begin, pos-begin );
    pos = string::npos;
    return string();
}
//////////////////////////////////
void Word::add_memory( const size_t size ){
    count += size;
    string * ptr = new string[count]; // выделяем новую память

    if( array ){ // если выделяем не в первый раз
        for( int i=0; i<count-size; i++ )
            ptr[i] = array[i];
        delete [] array; // удаляем старую память
    }
    array = ptr;
}
///////////////////////////////////
void Word::erase( size_t begin, size_t size ){
    Word w;
    for( size_t i = 0; i < begin && i < count; i++ )
        w += this->array[i];
    for( size_t i = begin + size; i < count; i++ )
        w += this->array[i];
    *this = w;
}
///////////////////////////////////////////
void Word::_null(){
    end_str = "\n";
    count = 0;
    array = NULL;
}
//_________ MAIN_________________
int main(int argc, char *argv[])
{ 
    // проверяем функции класса Word:
    Word w("aaa   bbb"); // конструктор принимающий строку char*
    w += "ccc"; // добавление слова char*
    w += w; // добавление слов из массива слов
    w.erase( 4 ); // удаление слова
    w.erase( 3, 2 ); // удаление двух слов
    cout << w; // вывод слов в поток ( консоль )
    cout << "\n\nEnter string: "; // "Введите слова"
    cin >> w; // ввод слов из потока
    w.end_str = ", "; // символ разделитель для вывода
    cout << "\n" << w << "\n\n";
    w.end_str = "\n";
    cout << w.end_str << w;
    fflush( stdin );

    
    // чтение строк из файла
    string str;
    cout << "\n\nEnter filename : ";
    cin >> str;
    ifstream file;
    file.open( str.c_str());// открываем файл
    if( !file.is_open()){
        cout << "\n\nError open file...";
        getchar();
        getchar();
        return 1;
    }
    while( !file.eof()){
        file >> w; // считываем слова из файла
    }
    cout << w; // выводим их на косоль
    getchar(); // пауза
    getchar();
    return 0;
}

Автор: Mcicool 9.11.2006, 16:20

error C2593: 'operator <<' is ambiguous
error C2593: 'operator >>' is ambiguous
Все 6 ошибок одинаковые, только в разных строчках, и позоду все в функции main() .

Автор: Mcicool 9.11.2006, 17:53

Еще вопрос такой: Зачем Вы используете виртуальный деструктор??
Что такое вообще virtual ??

Автор: Oleg_Ci 9.11.2006, 19:20

слово virtual убрать можно, оно для случая если наследование от этого класса будет, подробности в книге лучше почитать, я хорошо не объясню.
Кстати только-что доделал класс для себя, можеш его взять, ещё она у меня с русскими буквами теперь работает.
И уменя ошибок невыдаёт MVS2003.
Прога версия№ 4 :

Код


#include <iostream>
#include <locale>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

class Word
{
private:
    vector<string> array; // динамический массив слов
    
public:
    string end_str; // символ разделитель выводимый при выводе слов в поток ("\n")

    Word() :end_str("\n") {}; // кнструктор по умолчанию
    Word( const string & str ); // кoнструктор
    Word( const char * str );
    Word( const Word & w ); // конструктор копирования
    ~Word(); // деструктор

    Word & operator=( const Word &w ); // оператор присвоения
    Word operator+( const Word & w ); // складывание массивов слов
    Word operator+( const string & str ); // прибавление слов тип - string
    Word operator+( const char * str ); // добавление слов тип - char*
    Word & operator+=( const Word & w );
    Word & operator+=( const string & str );
    Word & operator+=( const char * str );
    friend Word & operator+( const string & str, Word & w );
    friend Word & operator+( const char * str, Word & w );
    const string & operator[](  const size_t pos )const;
    string & operator[](  const size_t pos ); // получение слова по индексу

    friend istream & operator>>( istream & in, Word & w ); // чтение слов из потока
    friend ostream & operator<<( ostream & out, const Word & w ); // вывод слов в поток

    void erase( const size_t begin = 0, const size_t size = 1 ); // удаление слов c позиции - begin, количеством - size
    void clear(); // удаление всех слов
    void push_str( const string & str ); // добавление слов из строки
    size_t size() { return array.size(); } // количество слов в массиве
    const size_t size()const { return array.size(); }
};


////////// конструктры /////////////////////////////
Word::Word( const string & str ) :end_str("\n"){
    *this += str;
}
/////////////////////////
Word::Word( const Word & w ) :end_str("\n"){
    *this = w;
}
////////////////////////
Word::Word( const char * str ) :end_str("\n"){
    *this += str;
}
////////////////////// деструктор ///////////////
Word::~Word(){
    array.clear();
}
////////// операторы ///////////////////////////////
Word & Word::operator=( const Word &w ){
    if( this == &w ) return *this;
    array.clear();
    copy( w.array.begin(), w.array.end(), back_inserter( this->array));
    return *this;
}
///////////////////////////////////
Word Word::operator+( const string & str ){
    Word w;
    w.push_str( str );
    return w;
}
//////////////////////////////////
Word Word::operator+( const char * str ){
    return Word::operator +( string(str));
}
//////////////////////////////////
Word Word::operator+( const Word & w ){
    Word wd;
    copy( w.array.begin(), w.array.end(), back_inserter( wd.array ));
    return wd;
}
/////////////////////////////////
Word & operator+( const string & str, Word & w ){
    w.push_str( str );
    return w;
}
/////////////////////////////////
Word & operator+( const char * str, Word & w ){
    w.push_str( string(str));
    return w;
}
/////////////////////////////////
Word & Word::operator+=( const Word & w ){
    array.reserve( array.size() + w.array.size());
    copy( w.array.begin(), w.array.end(), back_inserter( array ));
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const string & str ){
    this->push_str( str );
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const char * str ){
    *this += string( str );
    return *this;
}
//////////////////////////////////
istream & operator>>( istream & in, Word & w ){
    string str;
    getline( in, str ); // читаем из потока строку
    w.push_str( str ); // записываем слова в массив
    return in;
}
//////////////////////////////////
ostream & operator<<( ostream & out,const Word & w ){
    for( size_t i=0; i<w.size(); i++ )
        out << w[i] << w.end_str; // выводим строки в поток с символом разделителем
    return out;
}
////////////////////////////////////
const string & Word::operator[](  const size_t pos )const{
    return array[pos]; 
}
////////////////////////////////////
string & Word::operator[](  const size_t pos ){
    return array[pos]; // возвращаем слово по индексу в массиве
}
/////////// функции ////////////////////////////////////
void Word::push_str( const string & str ){
    //string s = ToOem( str );
    locale loc(".866");
    string::size_type begin, pos = 0;
    do{
        begin = pos; // начало слова
        for(; str[begin] && !isalpha( str[begin], loc ); begin++ );
        for( pos = begin; str[begin] && isalpha( str[pos], loc ); pos++ ); // конец слова - pos
        array.push_back(string( str, begin, pos - begin ));
    }while( pos < str.size() && pos != begin );
}

///////////////////////////////////
void Word::erase( const size_t begin, const size_t size ){
    array.erase( array.begin()+begin, array.begin() + begin + size );
}
///////////////////////////////////
void Word::clear(){
    array.clear();
}
//////////  MAIN ///////////
int main(){
    Word w("ad ads");
    w += w + "gdgdgd";
    cout << w;
    w.clear();
    cin >> w;
    cout << "\n\n" << w;
    fflush(stdin);
    getchar();
    return 0;
}

Автор: Mcicool 9.11.2006, 21:20

Что такое locale loc(".866"); ??
Вообщк что нам дает библиотека <locale> ??

Автор: Oleg_Ci 10.11.2006, 09:46

Цитата(Mcicool @ 10.11.2006, 01:20

)

Что такое locale loc(".866");

Код


locale loc(".866");

// здесь определяем принадлежность символа к русскому и латинскому алфавиту
// если без локали, то определять будем только для латинского алфавита.
isalpha( str[begin], loc )

Автор: Mcicool 10.11.2006, 10:49

Dev-C++ выдает такую ошибку:
prog8.cpp:2: locale: No such file or directory

Автор: Oleg_Ci 10.11.2006, 14:56

Ну токда "убери локаль", подключи библиотеку <ctype.h> или <cctype>

Код


//#include <locale>  << в место этого :
#include <cctype>
...

// locale loc(".866"); << убрать
// ...  isalpha( str[begin], loc ) ...  << и вместо этого :

isalpha( str[begin] ) // вот это.

Только теперь с русскими буквами не будет работать. smile

Автор: Mcicool 10.11.2006, 16:47

Я так сделал, только теперь 5 ошибок ))
161: implicit declaration of function `int getchar(...)'
160: implicit declaration of function `int fflush(...)'
160: for each function it appears in.)
160: (Each undeclared identifier is reported only once
160: `stdin' undeclared (first use this function)
In function `int main()':

Автор: Oleg_Ci 10.11.2006, 17:49

Эту программу попробуй на своём компиляторе.

Код


#include <iostream>
#include <cctype>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;


class Word
{
private:
    vector<string> array; // динамический массив слов
    
public:
    string end_str; // символ разделитель выводимый при выводе слов в поток ("\n")

    Word() :end_str("\n") {}; // кнструктор по умолчанию
    Word( const string & str ); // кoнструктор
    Word( const char * str );
    Word( const Word & w ); // конструктор копирования
    ~Word(); // деструктор

    Word & operator=( const Word &w ); // оператор присвоения
    Word operator+( const Word & w ); // складывание массивов слов
    Word operator+( const string & str ); // прибавление слов тип - string
    Word operator+( const char * str ); // добавление слов тип - char*
    Word & operator+=( const Word & w );
    Word & operator+=( const string & str );
    Word & operator+=( const char * str );
    friend Word & operator+( const string & str, Word & w );
    friend Word & operator+( const char * str, Word & w );
    const string & operator[](  const size_t pos )const;
    string & operator[](  const size_t pos ); // получение слова по индексу

    friend istream & operator>>( istream & in, Word & w ); // чтение слов из потока
    friend ostream & operator<<( ostream & out, const Word & w ); // вывод слов в поток

    void erase( const size_t begin = 0, const size_t size = 1 ); // удаление слов c позиции - begin, количеством - size
    void clear(); // удаление всех слов
    void push_str( const string & str ); // добавление слов из строки
    size_t size() { return array.size(); } // количество слов в массиве
    const size_t size()const { return array.size(); }
};


////////// конструктры /////////////////////////////
Word::Word( const string & str ) :end_str("\n"){
    *this += str;
}
/////////////////////////
Word::Word( const Word & w ) :end_str("\n"){
    *this = w;
}
////////////////////////
Word::Word( const char * str ) :end_str("\n"){
    *this += str;
}
////////////////////// деструктор ///////////////
Word::~Word(){
    array.clear();
}
////////// операторы ///////////////////////////////
Word & Word::operator=( const Word &w ){
    if( this == &w ) return *this;
    array.clear();
    copy( w.array.begin(), w.array.end(), back_inserter( this->array));
    return *this;
}
///////////////////////////////////
Word Word::operator+( const string & str ){
    Word w;
    w.push_str( str );
    return w;
}
//////////////////////////////////
Word Word::operator+( const char * str ){
    return Word::operator +( string(str));
}
//////////////////////////////////
Word Word::operator+( const Word & w ){
    Word wd;
    copy( w.array.begin(), w.array.end(), back_inserter( wd.array ));
    return wd;
}
/////////////////////////////////
Word & operator+( const string & str, Word & w ){
    w.push_str( str );
    return w;
}
/////////////////////////////////
Word & operator+( const char * str, Word & w ){
    w.push_str( string(str));
    return w;
}
/////////////////////////////////
Word & Word::operator+=( const Word & w ){
    array.reserve( array.size() + w.array.size());
    copy( w.array.begin(), w.array.end(), back_inserter( array ));
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const string & str ){
    this->push_str( str );
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const char * str ){
    *this += string( str );
    return *this;
}
//////////////////////////////////
istream & operator>>( istream & in, Word & w ){
    string str;
    getline( in, str ); // читаем из потока строку
    w.push_str( str ); // записываем слова в массив
    return in;
}
//////////////////////////////////
ostream & operator<<( ostream & out,const Word & w ){
    for( size_t i=0; i<w.size(); i++ )
        out << w[i] << w.end_str; // выводим строки в поток с символом разделителем
    return out;
}
////////////////////////////////////
const string & Word::operator[](  const size_t pos )const{
    return array[pos]; 
}
////////////////////////////////////
string & Word::operator[](  const size_t pos ){
    return array[pos]; // возвращаем слово по индексу в массиве
}
/////////// функции ////////////////////////////////////
void Word::push_str( const string & str ){
    //string s = ToOem( str );
    //locale loc(".866");
    string::size_type begin, pos = 0;
    do{
        begin = pos; // начало слова
        for(; str[begin] && !isalpha( str[begin] ); begin++ );
        for( pos = begin; str[begin] && isalpha( str[pos] ); pos++ ); // конец слова - pos
        array.push_back(string( str, begin, pos - begin ));
    }while( pos < str.size() && pos != begin );
}

///////////////////////////////////
void Word::erase( const size_t begin, const size_t size ){
    array.erase( array.begin()+begin, array.begin() + begin + size );
}
///////////////////////////////////
void Word::clear(){
    array.clear();
}
//////////  MAIN ///////////
int main(){
    Word w("ad ads");
    w += w + "gdgdgd";
    cout << w;
    w.clear();
    cin >> w;
    cout << "\n\n" << w;
    cin.sync();
    cin.get();
    return 0;
}

Автор: Mcicool 10.11.2006, 18:24

Урааа, скомпилилась! Спасибо!
Только вот что непонятно:
Я ее включаю, а там на экране:
ad
ads
gdgdgd
Потом ввожу любое слово, он его копирует, и все.
Что она делать вообще должна?

Автор: Oleg_Ci 10.11.2006, 18:44

так ты вводи не одно слово а несколько сразу, скажем "asd adsd sf s d d d d".
или код из функции main из других программ возьми, там где с файлами...
да я вроде объяснял чего класс умеет делать, скажем из файла читать слова,
складыват Word со строками, удаляет строки(кстати последнюю версию функции удаления я не проверил... извиняй если что...)

Автор: Mcicool 10.11.2006, 19:00

Word w("ad ads");
w += w + "gdgdgd";

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

Автор: Oleg_Ci 11.11.2006, 08:46

Ну так нормально ?
здесь ещё исправил ошибки которые нашёл smile

Код


#include <iostream>
#include <fstream>
#include <cctype>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;

class Word
{
private:
    vector<string> array; // динамический массив слов
    
public:

    Word() :end_str("\n") {}; // кнструктор по умолчанию
    Word( const string & str ); // кoнструктор принимающий строку string
    Word( const char * str ); // кoнструктор принимающий строку char*
    Word( const Word & w ); // конструктор копирования
    ~Word(); // деструктор

    Word & operator=( const Word &w ); // оператор присвоения
    Word operator+( const Word & w ); // складывание массивов слов
    Word operator+( const string & str ); // прибавление слов тип - string
    Word operator+( const char * str ); // добавление слов тип - char*
    Word & operator+=( const Word & w ); // добавление в массив слов из другого массива
    Word & operator+=( const string & str ); // добавление слов из строки string
    Word & operator+=( const char * str ); // добавление слов из строки char *
    friend Word operator+( const string & str, Word & w ); // складывание Word и строки string
    friend Word operator+( const char * str, Word & w ); // складывание Word и строки char *
    const string & operator[](  const size_t pos )const; // получение константного слова по индексу
    string & operator[](  const size_t pos ); // получение слова по индексу

    friend istream & operator>>( istream & in, Word & w ); // чтение слов из потока
    friend ostream & operator<<( ostream & out, const Word & w ); // вывод слов в поток

    void erase( const size_t begin = 0, const size_t size = 1 ); // удаление слов c позиции - begin, количеством - size
    void clear(); // удаление всех слов
    void push_str( const string & str ); // добавление слов из строки string
    void push_str( const char * str ); // добавление слов из строки char *
    size_t size() { return array.size(); } // количество слов в массиве
    const size_t size()const { return array.size(); }
    string end_str; // символ разделитель выводимый при выводе слов в поток ("\n")
};


////////// конструктры /////////////////////////////
Word::Word( const string & str ) :end_str("\n"){ // симол разделитель при выводе слов в поток = "\n"
    push_str( str ); // добавляем в массив слова из строки string str
}
/////////////////////////
Word::Word( const Word & w ) :end_str("\n"){
    array.reserve(w.array.size());// резервируем память для предотвращения перераспределения(необязятельно)
    array = w.array; // копируем слова
}
////////////////////////
Word::Word( const char * str ) :end_str("\n"){
    push_str( str ); // добавляем в массив слова из строки char * str
}
////////////////////// деструктор ///////////////
Word::~Word(){
    array.clear(); // очистка массива
}
////////// операторы ///////////////////////////////
Word & Word::operator=( const Word &w ){
    if( this == &w ) return *this; // ели пытаемся присвоить "сябя самому себе"
    array.clear(); // удаляем все слова из массива слов
    array.reserve(w.array.size());// резервируем память для предотвращения перераспределения(необязятельно)
    array = w.array; // копируем слова
    return *this;
}
///////////////////////////////////
Word Word::operator+( const string & str ){
    Word w( *this ); // копируем слова в новый массив
    w.push_str( str ); // добавляем слова в новый массив
    return w; // возвращиаем новый массив
}
//////////////////////////////////
Word Word::operator+( const char * str ){
    Word w( *this ); // тоже сомое что и в Word Word::operator+( const string & str )
    w.push_str( str );
    return w;
}
//////////////////////////////////
Word Word::operator+( const Word & w ){
    Word wd( *this );
    copy( w.array.begin(), w.array.end(), back_inserter( wd.array )); // добавляем слова в новый массив
    return wd;
}
/////////////////////////////////
Word operator+( const string & str, Word & w ){
    Word wd( w );
    wd.push_str( str );
    return wd;
}
/////////////////////////////////
Word operator+( const char * str, Word & w ){
    Word wd( w );
    wd.push_str( str );
    return wd;
}
/////////////////////////////////
Word & Word::operator+=( const Word & w ){
    array.reserve( array.size() + w.array.size());// резервируем память для предотвращения перераспределения(необязятельно)
    copy( w.array.begin(), w.array.end(), back_inserter( this->array ));
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const string & str ){
    push_str( str );
    return *this;
}
//////////////////////////////////
Word & Word::operator+=( const char * str ){
    push_str( str );
    return *this;
}
//////////////////////////////////
istream & operator>>( istream & in, Word & w ){
    string str;
    getline( in, str ); // читаем из потока строку
    w.push_str( str ); // записываем слова в массив
    return in;
}
//////////////////////////////////
ostream & operator<<( ostream & out,const Word & w ){
    for( size_t i=0; i<w.size(); i++ )
        out << w[i] << w.end_str; // выводим строки в поток с символом разделителем
    return out;
}
////////////////////////////////////
const string & Word::operator[](  const size_t pos )const{
    return array[pos];
}
////////////////////////////////////
string & Word::operator[](  const size_t pos ){
    return array[pos]; // возвращаем слово по индексу в массиве
}
/////////// функции ////////////////////////////////////
void Word::push_str( const string & str ){
    string::size_type begin, pos = 0; // начало и конец слова в строке
    do{
        begin = pos;
        for(; str[begin] && !isalpha( str[begin] ); begin++ ); // начало слова
        for( pos = begin; str[begin] && isalpha( str[pos] ); pos++ ); // конец слова - pos
        array.push_back(string( str, begin, pos - begin ));
    }while( pos < str.size() && pos != begin );
}
//////////////////////////////////
void Word::push_str( const char * str ){
    int begin, pos = 0; // начало и конец слова в строке
    do{
        begin = pos; // начало слова
        for(; str[begin] && !isalpha( str[begin] ); begin++ ); // поиск начала слова - begin
        for( pos = begin; str[begin] && isalpha( str[pos] ); pos++ ); // поиск конца слова - pos
        array.push_back(string( &str[begin], pos - begin )); // добавляем слово в массив
    }while( str[pos] && pos != begin ); // считываем слова из строки пока есть непрочитанные буквы
}
///////////////////////////////////
void Word::erase( const size_t begin, const size_t size ){
    array.erase( array.begin()+begin, array.begin() + begin + size );
}
///////////////////////////////////
void Word::clear(){
    array.clear();
}
//////////  MAIN ///////////
int main(){
    // проверки
    Word w("ad ads");// создаём массив слов ( 2 слова "as" и "asd" )
    w += w + "ssssss www"; // прибавляем к массиву Word такойже массив и две строки
    w += "fgf"; // добавляем "fdf" в массив
    cout << w; // выводим все слова, а между словами вставляем символ Word.end_str = "\n"
    w.end_str = ", ";
    w.erase( 1 ); // удаляем второе слово ( нумерация с 0 )
    w.erase( 3, 2 ); // удаляем два слова, четвёртое и пятое
    cout << "\n\n" << w; // вывод слов через запятую
    w.end_str = "\n";
    w.clear(); // удаляем все слова из массива
    cout << "\n\nEnter string > "; // "введите строку > "
    cin >> w; // считываем строку(слова) с консоли
    cout << "\n\n" << w; // выводим считанные слова на консоль

    Word s(w); // проверяем конструктор копирования
    s.end_str = ", ";
    cout << "\n" << s; // вывод скопированных слов

    // считывание слов из файла
    ifstream file;
    cout << "\n\nEnter filename > "; // "Введите имя файла"
    string name;
    cin >> name;
    file.open( name.c_str() ); // открываем файл name
    if( !file.is_open()){ // если не открылся
        cout << "Error open file " << name << " !!!";
        cin.sync();
        cin.get();
        return 0; // выход из программы
    }
    w.clear(); // удаляем слова из массива
    while( file >> w ); // считываем строки(слова) пока считывается
    cout << w; // выводим слова которые считали из файла

    cin.sync(); // очистка буфера ввода
    cin.get(); // пауза
    return 0;
}

Автор: Mcicool 11.11.2006, 13:00

Код


    Word w("ad ads");
    w += w + "ssssss www"; 
    w += "fgf"; 
    cout << w; Word.end_str = "\n"
    w.end_str = ", ";
    w.erase( 1 ); 
    w.erase( 3, 2 ); 
    cout << "\n\n" << w;

А зачем нам нужен этот участок кода? Зачем мы прибавляем какие то буквы, потом стираем? И когда, я имя файла вбиваю, программа просто выходит... Че то я вообщене пойму, как она работает... Извините конечно...

Добавлено @ 13:02
аа, просто какое бы имя файла я не ввел, все равно программа выходит.

Автор: Oleg_Ci 11.11.2006, 17:55

Цитата(Mcicool @ 11.11.2006, 17:00

)

А зачем нам нужен этот участок кода?

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

Цитата(Mcicool @ 11.11.2006, 17:00

)

просто какое бы имя файла я не ввел, все равно программа выходит.

Файл у тебя в тойже папке что и исходники программы?
Вообще-то у меня нормально открывает файлы, и читает слова от туда.
И вводишь имена файлов с расширением ?
Например есть текстовый файл, в папке с тектом программы, называется "text.txt" , запускаем программу, после запроса "Enter filename > " вводим название файла "text.txt" ( без ковычек ).
Ну вот ты всё также делаешь ?

Автор: Mcicool 12.11.2006, 14:40

У меня так :
Enter filename> Пишу: text.txt
//Файл находится в той же директории.
И в итоге ничего не делается... странно.
Кстати, а вы мне не посоветуйете нормальный компилятор, а тоя думаю, в этом тоже проблема.

Автор: Oleg_Ci 12.11.2006, 17:00

Попробуй исправить

Код


int main()
...
// в место этого :
if( !file.is_open()){ // если не открылся

// вот так попробуй :
if( !file ){ // если не открылся

Кстати эти штуки удалить лучше, они неправильно smile

размер резервируют.

Код


array.reserve( array.size() + w.array.size());// резервируем память для предотвращения перераспределения(необязятельно)

Кстати компилятор у меня Microsoft visual studio 2003 ( mvs2003 ).
какие хорошие незнаю, да мне и ненадо, я учись ещё.

Автор: Mcicool 12.11.2006, 22:23

Эхх, все равно такая же фигня smile

А вы можете сделать так же, только без проверок всяких?

Автор: Oleg_Ci 13.11.2006, 15:23

Цитата(Mcicool @ 13.11.2006, 02:23

)

А вы можете сделать так же, только без проверок всяких?

Ну удали тогда этот код и всё.

Код


if( !file.is_open()){ // если не открылся
        cout << "Error open file " << name << " !!!";
        cin.sync();
        cin.get();
        return 0; // выход из программы
    }

Автор: Mcicool 13.11.2006, 16:39

Да все равно, теперь просто вылетает, когда я ввожу имя файла. Блин, чеж такое то ((((

Автор: Oleg_Ci 14.11.2006, 15:41

Попробуй так открывать:

Код


// в место этого :
file.open( name.c_str() ); // открываем файл name
// так :
file.open( name.c_str(), ios_base::in ); // открываем файл name
file.open( name.c_str(), ios::in ); // открываем файл name

Если не поможет, то я незнаю что ещё тебе помочь может...
Попробуй отдельную тему создать про открытие файлов...