Консультации Портала - Консультация #184303

Задать вопрос Консультации Пользователи Форум

Задать вопрос экспертам

Консультация № 184303

21.10.2011, 23:08

62.66 руб.

0 6 1

Компьютеры Программирование

Здравствуйте, уважаемые эксперты! Прошу вас ответить на следующий вопрос:
Структура данных “строка”. Нужно:
1. Текст модуля для реализации СД типа “строка”, текст программы для отладки модуля, тестовые данные результат работы программы.
2. Текст программы для решения задачи с использованием модуля, тестовые данные, результат работы программы.

Реализовать в Borland C++ Builder 6.0
Задание:
Заголовок: short function Word(string s).
Назначение: подсчет числа слов в строке s.
Входные параметры: s.
Выходные параметры: нет.

Использовать данный формат:
typedef char[65520] char1
struct string1{
char1 * st;{ признак конца строки–символ с кодом 0}
short n {количество символов в строке,определяется}
} ; {при инициализации}

void function InitStr(string1 st, short n)
void function WriteToStr(string1 st, string s) ;
void function WriteFromStr(string1 st, string s);
void function InputStr(string1 st)
void function OutputStr(string1const st)
bool function Comp(string1 s1, string1 s2, short fl)
void function Delete(string1 s, short index, short count)
void function Insert(String1 Subs, String1 S,short Index)
void function Concat(string1 S1, string1 S2, string1 srez)
void function Copy(String1 S,short Index, short Count, string1 Subs)
short function Length(string1 S)
short function Pos(string1 SubS, String1 S)
StrError: {тип переменной ошибки}

И желательно максимально прокомментировать все строки программы.Сапсибо!!!

Обсуждение

Неизвестный

23.10.2011, 21:21

общий

Какая-то тут у Вас смесь языков... Насколько мне известно, в С++ нет ключевого слова function и комментарии помещаются в /*...*/, а не {...}.
И не понятно, что такое StrError...

Неизвестный

23.10.2011, 21:40

общий

Могу привести похожий код.
13.Заголовок: void function Trail(string s).
Назначение: удаление голов¬ных и хвостовых пробелов.
Входные параметры: s.
Выходные параметры: s.

Формат
struct string1{
char St[1024];
short N {динамическая длина строки}
};
void function WriteToStr(string1 st, string s) ;
void function WriteFromStr(string1 st, string s);
void function InputStr(string1 st)
void function OutputStr(string1const st)
bool function Comp(string1 s1, string1 s2, short fl)
void function Delete(string1 s, short index, short count)
void function Insert(String1 Subs, String1 S,short Index)
void function Concat(string1 S1, string1 S2, string1 srez)
void function Copy(String1 S,short Index, short Count, string1 Subs)
short function Length(string1 S)
short function Pos(string1 SubS, String1 S)
StrError: {тип переменной ошибки}

Листинг 1 (mystr.h):

//---------------------------------------------------------------------------
#ifndef mstrH
#define mstrH
#include <iostream.h>
//---------------------------------------------------------------------------
const MAX_STR = 1024;
int STR_ERROR;
//1 - превышен предел максимально допустимой длины строки
//---------------------------------------------------------------------------
class string1 {
char st[MAX_STR];
int n;
//0 - s1 == s1;
//1 - s1 > s1;
//-1 - s1 < s2
int comp(const string1 &s1,const string1 &s2);
public:
string1();
string1(const int n,const char *s);
void reset();
string1& operator =(const string1 &s);
friend ostream& operator <<(ostream& o,const string1 &s);
friend istream& operator >>(istream& o,string1 &s);
bool operator >(const string1 &s);
bool operator <(const string1 &s);
bool operator ==(const string1 &s);
bool operator !=(const string1 &s);
string1 operator +(const string1 &s);
void Delete(int index,int count);
void Insert(const string1 &s,int index);
string1 Copy(int index,int count);
int Length();
int Pos(const string1& substr);
void Trail();
};
//---------------------------------------------------------------------------
#endif

Листинг 2 (mystr.cpp):

//---------------------------------------------------------------------------
#pragma hdrstop
#include "mstr.h"
//---------------------------------------------------------------------------
string1::string1() {
reset();
}
//---------------------------------------------------------------------------
string1::string1(const int n,const char *s) {
if (n > MAX_STR) {
string1();
STR_ERROR = 1;
return;
};
for (int i=0;i<n;i++)
this->st[i] = s[i];
this->n = n;
};
//---------------------------------------------------------------------------
void string1::reset() {
n = 0;
for (int i=0;i<MAX_STR;i++)
st[i] = 0;
};
//---------------------------------------------------------------------------
int string1::comp(const string1 &s1,const string1 &s2) {
int l = 0;
if (s1.n > s2.n) l = s2.n;
else l = s1.n;
int i = 0;
while ((s1.st[i] == s2.st[i]) && (i<l))
i++;
if (i == l)
if (s1.n == s2.n) {
return 0;
}
else
if (s1.n > s2.n)
return 1;
else return -1;
if (s1.st[i] > s2.st[i])
return 1;
else return -1;
};
//---------------------------------------------------------------------------
string1& string1::operator =(const string1 &s) {
reset();
for (int i=0;i<s.n;i++)
st[i] = s.st[i];
n = s.n;
return *this;
};
//---------------------------------------------------------------------------
ostream& operator <<(ostream& o,const string1 &s) {
int i = 0;
while (i < s.n)
o << s.st[i++];
return o;
};
//---------------------------------------------------------------------------
istream& operator >>(istream& o,string1 &s) {
s.reset();
o.getline(s.st,MAX_STR,'\n');
if (o.gcount() > MAX_STR)
STR_ERROR = 1;
s.n = o.gcount()-1;
return o;
};
//---------------------------------------------------------------------------
bool string1::operator >(const string1 &s) {
if (comp(*this,s) == 1)
return true;
else
return false;
};
//---------------------------------------------------------------------------
bool string1::operator <(const string1 &s) {
if (comp(*this,s) == -1)
return true;
else
return false;
};
//---------------------------------------------------------------------------
bool string1::operator ==(const string1 &s) {
if (comp(*this,s) == 0)
return true;
else
return false;
};
//---------------------------------------------------------------------------
bool string1::operator !=(const string1 &s) {
if (comp(*this,s) != 0)
return true;
else
return false;
};
//---------------------------------------------------------------------------
string1 string1::operator +(const string1& s) {
string1 result;
if (n+s.n < MAX_STR) {
for (int i=0;i<n;i++)
result.st[i] = st[i];
for (int i=n;i<n+s.n;i++)
result.st[i] = s.st[i-n];
result.n = n+s.n;
}
else STR_ERROR = 1;
return result;
};
//---------------------------------------------------------------------------
void string1::Delete(int index,int count) {
if (index < n)
if (index+count > n) {
n = index + 1;
}
else {
int i = index;
for (int j=index+count;j<n;j++)
st[i++] = st[j];
n = i;
}
};
//---------------------------------------------------------------------------
void string1::Insert(const string1 &s,int index) {
if (s.n + n < MAX_STR) {
for (int j=index;j<n;j++)
st[j+s.n] = st[j];
int i = 0;
for (int j=index;j<index+s.n-1;j++)
st[j] = s.st[i++];
n += s.n;
}
else STR_ERROR = 1;
};
//---------------------------------------------------------------------------
string1 string1::Copy(int index,int count) {
string1 res;
if (index+count > n) {
count -= n - (index+count);
STR_ERROR = 1;
};
for (int i = index;i<index+count;i++)
res.st[i - index] = st[i];
res.n = count;
return res;
}
//---------------------------------------------------------------------------
int string1::Length() {
return n;
}
//---------------------------------------------------------------------------
int string1::Pos(const string1& substr) {
int nom = 0;
if (n < substr.n)
return -1;
int i = 0,j = 0;
while ((st[i] != substr.st[j]) && (i < n - substr.n))
i++;
if (i == n-substr.n)
return -1;
nom = i;
while ((st[i] == substr.st[j]) && (j < substr.n))
i++;j++;
if (j == substr.n)
return nom;
else
return -1;
};
//---------------------------------------------------------------------------
void string1::Trail() {
int i = 0;
while (st[i] == ' ')
i++;
Delete(0,i);
int j = n-1;
while (st[j] == ' ')
j--;
Delete(j+1,n-(j+1));
};
//---------------------------------------------------------------------------
#pragma package(smart_init)

Для тестирования реализованного класса была написана демострационная программа:

Листинг 3 (Unit1.cpp):
//---------------------------------------------------------------------------
#pragma hdrstop
#pragma argsused
#include <mstr.cpp>
#include <iostream.h>
//---------------------------------------------------------------------------
int main(int argc, char* argv[])
{
string1 a;
cout << "Enter your name: ";
cin >> a;
a.Trail();

string1 b(10," Hellow ");
string1 c = b + a;
c.Trail();
cout << endl << c << endl;
cout << "In your name " << a.Length() << " letters.\n";
int p = a.Pos(string1(1,"t"));
if (p < 0)
cout << "There isn't letter 't' in your name.\n";
else
cout << "There is letter 't' in your name.\n It is " << p+1 << endl;

cout << "\nenter a: ";
cin >> a;
cout << "\nenter b: ";
cin >> b;
cout << "'" << a << "'";
if (a == b)
cout << " == ";
else
if (a > b)
cout <<" > ";
else
cout <<" < ";
cout << "'"<< b << "'\n\n";

a.reset();//a = "";
do {
cout << "Enter string form 10 letters: ";
cin >> a;
} while (a.Length() != 10);

b = a.Copy(5,3);
a.Delete(5,3);
c = a;
a.Insert(b,5);
cout << b << endl;
cout << c << endl;
cout << a << endl;

int t;
cin >> t;
return 0;
}

Неизвестный

23.10.2011, 21:46

общий

Это уже куда больше похоже на С++

Правда, с ТЗ весьма условно сочетается.
У меня есть вот такой класс (см. приложение). Пойдёт? Функцию подсчёта слов могу написать.

Прикрепленные файлы:

19821668af9dd264970d2316c82919c5.rar

скачать (2.00 кБ)

Неизвестный

23.10.2011, 21:50

общий

честно как то сложно очень)
и мне надо все четко по заданию, ничего лишнего не надо

Неизвестный

28.10.2011, 12:01

общий

Вот такой вариант тогда, старалась сделать точно по заданию, хотя его формулировка очень странная. Проверьте, пожалуйста, на работу в Builder, потому что у меня только Visual Studio сейчас.
Вот функция подсчёта слов:

Код:

int Word (String1 str) //считаем число слов
{
	int k = 0; //пока 0
	while (str.Length()>0) { //пока не кончится строка
		int p = str.Pos (" "); //ищем вхождение пробела
		if (p<0) {k++; break;} //если нет - суммируем последнее слово и выходим
		if (p>0) k++; //если пробел не на первой позиции, суммируем слово
		str.Delete (0, p+1); //удаляем слово и пробел
	}
	return k; //возвращаем число слов
}

Файлы класса в приложении.

Прикрепленные файлы:

3347bb2c779e4ec35b3ac4ee5f39d432.zip

скачать (2.00 кБ)

Неизвестный

29.10.2011, 00:01

общий

это ответ

Здравствуйте, Иванов Иван!
Вот пример реализации Вашей программы. Если что-то не так поняла в задании, скажите, поправлю, а то формулировка несколько странная. В приложении, собственно, класс строки. А вот пример того, как с его помощью можно написать функцию подсчёта числа слов. Поскольку в задании ничего не говорится о разделителях, используются только пробелы. Алгоритм подсчёта слов рассчитан на то, чтобы максимально продемонстрировать возможности класса, реально эту функцию я бы написала по-другому.

Код:

int Word (String1 str) //считаем число слов
{
	int k = 0; //пока 0
	while (str.Length()>0) { //пока не кончится строка
		int p = str.Pos (" "); //ищем вхождение пробела
		if (p<0) {k++; break;} //если нет - суммируем последнее слово и выходим
		if (p>0) k++; //если пробел не на первой позиции, суммируем слово
		str.Delete (0, p+1); //удаляем слово и пробел
	}
	return k; //возвращаем число слов
}

Проверяла на Visual Studio, но должно и на Borland-е работать. Если будут проблемы с синтаксисом, пишите, попробуем решить.
Удачи!

Приложение:
#ifndef STRING1_H
#define STRING1_H

const int max_len = 65520;

class String1 //класс строка
{
char s[max_len+1]; //буфер для строки
int n; //длина строки
int StrError; //флаг ошибки
public:
String1 (); //конструктор по умолчанию
String1 (const char* str, int n_); //конструктор из строки с заданной длиной
String1 (const char* str); //конструктор из строки
String1 (const String1 &str); //конструктор копирования
~String1 () {}; //деструктор (пустой)
String1& operator= (char *str); //присваивание строки
String1& operator= (String1 str); //присваивание другого объекта класса
const char* GetString(); //получение массива символов
bool Compare (String1 str, int ofs = 0); //сравнение на равенство, опционально указывается отступ
void Delete (int ofs = 0, int count = -1); //удаление count символов с ofs позиции (по умолчанию - удаление всей строки)
void Insert (String1 str, int ofs); //вставка на заданную позицию
void Concat (String1 str); //объекдинение
void Copy (String1& whr, int ofs, int count); //копирование
int Length (); //длина строки
int Pos (String1 str); //позиция подстроки (-1 в случае, если она отсутствует)
int GetError (); //получение флага ошибки
};

#endif

#include "StdAfx.h"
#include "String1.h"
#include <string.h>

String1::String1()
{
s[0] = '\0'; //по умолчанию пишем пустую строку
n = 0;
StrError = 0;
}

String1::String1 (const char* str, int n_)
{
if (n_>max_len) { //если заданная длина больше допустимой, пишем пустую строку и помечаем ошибку
StrError = 1;
s[0] = '\0';
n = 0;
return;
}
n = n_; //иначе копируем посимвольно
for (int i=0; i<n; i++)
s[i] = str[i];
s[n] = '\0';
StrError = 0;
}

String1::String1 (const char* str)
{
int l = strlen (str); //всё, как и в предыдущей, но длину строки вычисляем сами
if (l>max_len) {
StrError = 1;
s[0] = '\0';
n = 0;
return;
}
n = l;
for (int i=0; i<n; i++)
s[i] = str[i];
s[n] = '\0';
StrError = 0;
}

String1::String1 (const String1 &str)
{
strcpy (s, str.s); //копируем всё из другого объекта
n = str.n;
StrError = 0;
}

String1& String1::operator= (char *str)
{
if (strlen(str)>max_len) { //аналогично контруктору из строки
StrError = 1;
return *this;
}
n = strlen(str);
strcpy (s, str);
StrError = 0;
return *this; //возвращаем себя
}

String1& String1::operator= (String1 str)
{
strcpy (s, str.s); //аналогично конструктору копирования
n = str.n;
StrError = 0;
return *this;
}

const char* String1::GetString()
{
StrError = 0;
return s; //возвращаем буфер
}

bool String1::Compare (String1 str, int ofs)
{
StrError = 0;
for (int i=0; i<n && i+ofs<str.n; i++) //посимвольно сравниваем
if (s[i]!=str.s[i+ofs]) return false; //при несовпадении возвращаем 0
return true; //если дошли досюда, то строки равны
}

void String1::Delete (int ofs, int count)
{
if (count == -1) count = n-ofs; //в случае параметра по умолчанию
if (ofs>=n || count>n) { //проверяем корректность диапазона
StrError = 1;
return;
}
StrError = 0;
for (int i = ofs; i<=n-count; i++) //сдвигаем массив символов влево
s[i] = s[i+count]; //затираем ненужное
n -= count; //уменьшаем размер
}

void String1::Insert (String1 str, int ofs)
{
if (n+str.n>max_len) { //проверяем, влезает ли
StrError = 1;
return;
}
for (int i=n+str.n; i>=ofs+str.n; i--) //освобождаем место
s[i] = s[i-str.n]; //сдвигаем массив вправо
for (int i=0; i<str.n; i++) //копируем данные
s[ofs+i] = str.s[i];
n+=str.n; //увеличиваем размер
StrError = 0;
}

void String1::Concat (String1 str)
{
if (n+str.n>max_len) { //проверяем, влезает ли
StrError = 1;
return;
}
for (int i = 0; i< str.n; i++) //дописываем в конец
s[n+i] = str.s[i];
s[n+str.n] = '\0'; //проставляем конец строки
n+=str.n; //увеличиваем длину
StrError = 0;
}

void String1::Copy (String1& whr, int ofs, int count)
{
if (ofs>=n || count>n) { //проверяем корректность диапазона
StrError = 1;
return;
}
String1 tmp (s+ofs, count); //делаем новую строку из старой со сдвигом на ofs и длиной count
whr = tmp; //присваиваем новый объект возвращаемому
StrError = 0;
}

int String1::Length ()
{
StrError = 0;
return n; //возврашаем длину
}

int String1::Pos (String1 str) //ищет только первое вхождение
{
StrError = 0;
if (str.n>n) return -1; //если длина искомой строки больше исходной, её точно у нас нет
for (int i = 0; i< n; i++) //идём по строке
if (s[i]==str.s[0]) { //встретили совпадаюший первый символ
bool f = true; //готовим флаг
for (int j = 1; j<str.n && f; j++) //идём по подстроке
if (s[i+j]!=str.s[j]) f = false; //если какой-то символ не совпал - ошибка
if (f) return i; //если флаг не сброшен, возвращаем полученную позицию
}
return -1; //если попали сюда, подстроки нет
}

int String1::GetError ()
{
return StrError; //фозвращаем флаг ошибки
}

Форма ответа

Отправка постов/ответов доступна только зарегистрированным и подтвержденным пользователям.

Если Вы уже зарегистрированы на Портале - войдите в систему, если Вы еще не регистрировались - пройдите простую процедуру регистрации.