Checked

Can anyone give me a hint as to why there are garbage symbols after checked option?

double CoinStack::value()

double CoinStack::value(){
  double value = 0.0;
  Coin C;
  open(_fname, ios::out|ios::binary);
  if(!fail()){
    while(!IsEmpty()){
      C = pop();
      value += (int)C;
      write((const char*)&C, sizeof(C));
    }
  }
  close();
  open(_fname, ios::in|ios::binary);
  if(!fail()){
    seekg(0, ios::end);
    int curloc = (int)tellg() - sizeof(Coin);
    while(curloc >= 0){
      seekg((ios::pos_type)curloc);
      read((char*)&C, sizeof(C));
      push(C);
      curloc -= sizeof(C);
    }
  }
  close();
  clear();
  open(_fname, ios::out|ios::trunc);
  close();
  return value;
}

Backward Binary Print with seekg and ios::cur

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

int main(){
  int i;
  int loc;
  fstream file("output.bin", ios::in|ios::binary);
  while(!file.fail()){
    file.read((char*)&i, sizeof(i));
    if(!file.fail()){
      cout<<i<<", ";
    }
  }
  cout<<endl;
  file.clear();
  cout<<(loc = file.tellg())<<endl;
  loc -= sizeof(int);
  while (loc >= 0){
    file.seekg((ios::pos_type)loc);
    file.read((char*)&i, sizeof(i));
    cout<<i<<", ";
    loc -= sizeof(int);
  }
  file.seekg((ios::off_type)0, ios::end);
  while(file.tellg()) {
    file.seekg((ios::off_type)-(signed)sizeof(int), ios::cur);
    file.read((char*)&i, sizeof(i));
    cout<<i<<", ";
    file.seekg((ios::off_type)-(signed)sizeof(int), ios::cur);
  }
  return 0;
}

DLL Template

#ifndef __DLLTemp_H__
#define __DLLTemp_H__

template <class T>
class DLL;

template <class T>
class Node{
  T _data;
  Node<T>* _prev;
  Node<T>* _next;
  Node(T data, Node<T>* prev=(Node<T>*)0, Node<T>* next=(Node<T>*)0);// just incase, review later
  friend class DLL<T>;
};

template <class T>
class DLL{
  Node<T>* _head;
  Node<T>* _curr;
  Node<T>* _tail;
  void copy(DLL<T>& D);
public:
  DLL();
  DLL(DLL<T>& D);
  virtual ~DLL();
  bool isEmpty();
  void append(T data);
  DLL<T>& operator=(DLL<T>& D);
  T remove();   // removes the current node and returns the data
  bool del();     // removes the current node returns false if is empty
  void insert(T data); // insterts before current
  bool goHead();
  bool goTail();
  bool goNext();
  bool goPrev();
  T visit();    // returns the current data
};

template <class T>
Node<T>::Node(T data, Node<T>* prev, Node<T>* next){
  _data = data;
  _prev = prev;
  _next = next;
}

template <class T>
DLL<T>::DLL(){
  _head = _tail = _curr = 0;
}

template <class T>
DLL<T>::~DLL(){
  while(del());
}

template <class T>
void DLL<T>::copy(DLL<T>& D){
  int curpos;
  for(curpos=0;D.goPrev();curpos++); // findout where is current
  if(!D.isEmpty()){
    do{
      this->append(D.visit());
    }while(D.goNext());
  }
  for(D.goHead(), this->goHead();curpos;D.goNext(), this->goNext(),curpos--);
}

template <class T>
DLL<T>::DLL(DLL<T>& D){
  _head = _tail = _curr = 0;
  copy(D);
}

template <class T>
DLL<T>& DLL<T>::operator=(DLL<T>& D){
  while(del());
  copy(D);
  return *this;
}

template <class T>
void DLL<T>::append(T data){
  Node<T>* newnode = new Node<T>(data);
  if(_tail){  // ! empty
    _tail->_next = newnode;
    newnode->_prev = _tail;
    _tail = _curr = newnode;
  }
  else{
    _tail = _curr = _head = newnode;
  }
}

template <class T>
T DLL<T>::remove(){
  T data = visit();
  del();
  return data;
}

template <class T>
bool DLL<T>::del(){
  bool ok = false;
  if(_curr){
    ok = true;
    Node<T>* todel = _curr;
    if(_curr->_next){
      _curr->_next->_prev = _curr->_prev;
    }
    else{
      _tail = _tail->_prev;
    }
    if(_curr->_prev){
      _curr->_prev->_next = _curr->_next;
    }
    else{
      _head = _head->_next;
    }
    _curr = _curr->_next;
    delete todel;
  }
  return ok;
}

template <class T>
void DLL<T>::insert(T data){
  if(_head == _curr){
    _head = new Node<T>(data, (Node<T>*)0, _head);
    _curr->_prev = _head;
  }
  else {
    _curr->_prev = new Node<T>(data, _curr->_prev, _curr);
    _curr->_prev->_prev->_next = _curr->_prev;
  }
}

template <class T>
T DLL<T>::visit(){               // retruns data of current
return _curr->_data;
}

template <class T>
bool DLL<T>::goHead(){
  _curr = _head;
  return (_curr != 0);
}

template <class T>
bool DLL<T>::goTail(){
  _curr = _tail;
  return (_curr != 0);
}

template <class T>
bool DLL<T>::goNext(){
  bool rt = false;
  if(_curr->_next){
    rt = true;
    _curr = _curr->_next;
  }
  return rt;
}

template <class T>
bool DLL<T>::goPrev(){
bool rt = false;
  if(_curr->_prev){
    rt = true;
    _curr = _curr->_prev;
  }
  return rt;
}

template <class T>
bool DLL<T>::isEmpty(){
return !_head;
}



#endif

CCheckList Constructors

Hi,

the web documentation for CCheckList Constructor says:

Passes corresponding values to the Base class (CField)

The constructor for CField is:

CField::CField(int Row, int Col,int Width, int Height,

    void* Data,bool Bordered,const char* Border)

but I'm not sure what I'm suppose to pass to Height and Data

so I put

CCheckList::CCheckList(const char* Format, int Row, int Col, 
        int Width,bool radio, bool Bordered,
        const char* Border) :CField(Row, Col, Width, 0, 0, Bordered, Border){


Should I pass the two zeroes for Height and Data? If not, what am I suppose to pass?

DLL implemented

#include "dll.h"
Node::Node(int data, Node* prev, Node* next){
  _data = data;
  _prev = prev;
  _next = next;
}

DLL::DLL(){
  _head = _tail = _curr = 0;
}
DLL::~DLL(){
  while(del());
}
void DLL::copy(DLL& D){
  int curpos;
  for(curpos=0;D.goPrev();curpos++); // findout where is current
  if(!D.isEmpty()){
    do{
      this->append(D.visit());
    }while(D.goNext());
  }
  for(D.goHead(), this->goHead();curpos;D.goNext(), this->goNext(),curpos--);
}
DLL::DLL(DLL& D){
  _head = _tail = _curr = 0;
  copy(D);
}
DLL& DLL::operator=(DLL& D){
  while(del());
  copy(D);
  return *this;
}

void DLL::append(int data){
  Node* newnode = new Node(data);
  if(_tail){  // ! empty
    _tail->_next = newnode;
    newnode->_prev = _tail;
    _tail = _curr = newnode;
  }
  else{
    _tail = _curr = _head = newnode;
  }

}
int DLL::remove(){
  int data = visit();
  del();
  return data;
}
bool DLL::del(){
  bool ok = false;
  if(_curr){
    ok = true;
    Node* todel = _curr;
    if(_curr->_next){
      _curr->_next->_prev = _curr->_prev;
    }
    else{
      _tail = _tail->_prev;
    }
    if(_curr->_prev){
      _curr->_prev->_next = _curr->_next;
    }
    else{
      _head = _head->_next;
    }
    _curr = _curr->_next;
    delete todel;
  }
  return ok;
}
void DLL::insert(int data){
  if(_head == _curr){
    _head = new Node(data, (Node*)0, _head);
    _curr->_prev = _head;
  }
  else {
    _curr->_prev = new Node(data, _curr->_prev, _curr);
    _curr->_prev->_prev->_next = _curr->_prev;
  }
}

int DLL::visit(){               // retruns data of current
return _curr->_data;
}
bool DLL::goHead(){
  _curr = _head;
  return (_curr != 0);
}
bool DLL::goTail(){
  _curr = _tail;
  return (_curr != 0);
}
bool DLL::goNext(){
  bool rt = false;
  if(_curr->_next){
    rt = true;
    _curr = _curr->_next;
  }
  return rt;
}
bool DLL::goPrev(){
bool rt = false;
  if(_curr->_prev){
    rt = true;
    _curr = _curr->_prev;
  }
  return rt;
}
bool DLL::isEmpty(){
return !_head;
}