07.02.2013, 07:46. Просмотров 438. Ответов 3
Доброго всем времи суток!!!
Возникла проблема - создан класс "sequence" нужно дописать его так, чтобы он использовал динамический массив как private member переменную.
Класс должен отличаться от написанного:
- номер элементов, который может быть сохранён в "sequence" должен лимитироваться только количеством памяти поступной в свободном хранении (free store). При добавлении нового элемента размер массива данных должен автоматически увеличиваться.
- Необходимо определить: copy конструктор, assignment operator и destructor.
- Конструктор должен иметь default аргумент, который позволит пользователю установить первоначальную вместимость класса "sequence".
- Необходима функция - resize -которая позволит пользователю четко установить ёмкость "sequence".
Header file "sequence2":
| C++ |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
| // FILE: sequence2.h
// CLASS PROVIDED: sequence (part of the namespace main_savitch_4)
// There is no implementation file provided for this class since it is
// an exercise from Chapter 4 of "Data Structures and Other Objects Using C++"
//
// TYPEDEFS and MEMBER CONSTANTS for the sequence class:
// typedef ____ value_type
// sequence::value_type is the data type of the items in the sequence. It
// may be any of the C++ built-in types (int, char, etc.), or a class with a
// default constructor, an assignment operator, and a copy constructor.
//
// typedef ____ size_type
// sequence::size_type is the data type of any variable that keeps track of
// how many items are in a sequence.
//
// static const size_type DEFAULT_CAPACITY = _____
// sequence::DEFAULT_CAPACITY is the initial capacity of a sequence that is
// created by the default constructor.
//
// CONSTRUCTOR for the sequence class:
// sequence(size_t initial_capacity = DEFAULT_CAPACITY)
// Postcondition: The sequence has been initialized as an empty sequence.
// The insert/attach functions will work efficiently (without allocating
// new memory) until this capacity is reached.
//
// MODIFICATION MEMBER FUNCTIONS for the sequence class:
// void resize(size_type new_capacity)
// Postcondition: The sequence's current capacity is changed to the
// new_capacity (but not less that the number of items already on the
// list). The insert/attach functions will work efficiently (without
// allocating new memory) until this new capacity is reached.
//
// void start( )
// Postcondition: The first item on the sequence becomes the current item
// (but if the sequence is empty, then there is no current item).
//
// void advance( )
// Precondition: is_item returns true.
// Postcondition: If the current item was already the last item in the
// sequence, then there is no longer any current item. Otherwise, the new
// current item is the item immediately after the original current item.
//
// void insert(const value_type& entry)
// Postcondition: A new copy of entry has been inserted in the sequence
// before the current item. If there was no current item, then the new entry
// has been inserted at the front of the sequence. In either case, the newly
// inserted item is now the current item of the sequence.
//
// void attach(const value_type& entry)
// Postcondition: A new copy of entry has been inserted in the sequence after
// the current item. If there was no current item, then the new entry has
// been attached to the end of the sequence. In either case, the newly
// inserted item is now the current item of the sequence.
//
// void remove_current( )
// Precondition: is_item returns true.
// Postcondition: The current item has been removed from the sequence, and the
// item after this (if there is one) is now the new current item.
//
// CONSTANT MEMBER FUNCTIONS for the sequence class:
// size_type size( ) const
// Postcondition: The return value is the number of items in the sequence.
//
// bool is_item( ) const
// Postcondition: A true return value indicates that there is a valid
// "current" item that may be retrieved by activating the current
// member function (listed below). A false return value indicates that
// there is no valid current item.
//
// value_type current( ) const
// Precondition: is_item( ) returns true.
// Postcondition: The item returned is the current item in the sequence.
//
// VALUE SEMANTICS for the sequence class:
// Assignments and the copy constructor may be used with sequence objects.
//
// DYNAMIC MEMORY USAGE by the List
// If there is insufficient dynamic memory, then the following functions
// throw a BAD_ALLOC exception: The constructors, insert, attach.
#ifndef MAIN_SAVITCH_SEQUENCE_H
#define MAIN_SAVITCH_SEQUENCE_H
#include <cstdlib> // Provides size_t
namespace main_savitch_4
{
class sequence
{
public:
// TYPEDEFS and MEMBER CONSTANTS
typedef double value_type;
typedef std::size_t size_type;
static const size_type DEFAULT_CAPACITY = 30;
// CONSTRUCTORS and DESTRUCTOR
sequence(size_type initial_capacity = DEFAULT_CAPACITY);
sequence(const sequence& source);
~sequence( );
// MODIFICATION MEMBER FUNCTIONS
void resize(size_type new_capacity);
void start( );
void advance( );
void insert(const value_type& entry);
void attach(const value_type& entry);
void remove_current( );
void operator =(const sequence& source);
// CONSTANT MEMBER FUNCTIONS
size_type size( ) const;
bool is_item( ) const;
value_type current( ) const;
private:
value_type* data;
size_type used;
size_type current_index;
size_type capacity;
};
}
#endif |
|
Implementation file sequence 1:
| C++ |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
| // Section CSC-161-500 - Computer Science II: C++
// File Name: sequence1.cxx
// Student: Anna Pavlenko
// Homework Number: Homework Two
// Description: sequence1.cxx - an implementation file for the sequence class, version 1
// Last Changed:
// FILE: sequence1.cxx
//CLASS IMPLEMENTED: sequence
//INVARIANT for sequence class:
// 1. The number of items in the sequence is in the member variable used;
// 2. For an empty sequence, we do not care what is stored in any of data; for a
// non-empty sequence the items in the bag are stored in data[0] through
// data[used-1]. The items in a sequence are arranged in an order, one after another
#include <iostream>
#include <algorithm>
#include <cassert> // Provides assert function
#include "sequence1.h" // With value_type defined as double
using namespace std;
namespace main_savitch_3
{
// MODIFICATION MEMBER FUNCTIONS
sequence::sequence()
{
current_index = 0;
used = 0;
}
void sequence::start( )
{
current_index = 0;
}
void sequence::advance( )
{
assert(it_item());
current_index++;
}
//insert member function
void sequence::insert(const value_type&entry)
{
size_type i;
assert(size() < CAPACITY);
if(!is_item())
current_index = 0;
for (i = used; i > current_index; --i)
{
data[i] = data[i - 1];
data[current_index] = entry;
used++;
}
}
// attach member function
void sequence::attach(const value_type& entry);
{
size_type i;
assert(size() < CAPACITY);
if(!is_item())
data[current_index] = entry;
else
{
for (i = used; i > current_index+1; --i)
data[i] = data[i - 1];
data[current_index+1] = entry;
current_index++;
}
used++;
}
void sequence::remove_current( )
{
size_type i;
assert(is_item( ));
for (i = current_index+1; i < used; i++)
data[i-1] = data[i];
used--;
}
// CONSTANT MEMBER FUNCTIONS
sequence::size_type sequence::size( ) const
{
return used;
}
bool sequence::is_item( ) const
{
return (current_index < used);
}
sequence::value_type sequence::current( ) const
{
assert(is_item( ));
return data[current_index];
}
system("Pause");
return 0;
} |
|
Please, help!!!
