bu hatalar neden?

[Lewissi]

g++ da hata aliyorum. neden olabilir?

asagidaki dosyalar sIrasIyla BinayNode.h BinaryNode.cpp BinaryTree.h BinaryTree.cpp BinarySearchTree.h BinarySearchTree.cpp TestBinarySearchTree.cpp

main fonksiyonu TestBinarySearchTree.cpp de.




#ifndef BINARYNODE_H_
#define BINARYNODE_H_
#include<iostream>
using namespace std;
#include<string>
/*
template <class Comparable>
class BinaryNode;
*/
/*
* int max(int &a, int &b)
{
if(a>b)
return a;
else return b;
}
*/
template <class Comparable>
class BinaryTree;
template <class Comparable>
class BinarySearchTree;
template <class Comparable>
class BinaryNode{
public:
Comparable element;
BinaryNode *left;
BinaryNode *right;
static int size(BinaryNode *t);
static int height(BinaryNode *t);
void printPostOrder();
void printInOrder();
void printPreOrder();
BinaryNode *duplicate();
BinaryNode(const Comparable & theElement = Comparable(),
BinaryNode<Comparable> *lt=NULL,BinaryNode <Comparable>*rt=NULL) {}
~BinaryNode(){}
};
#endif






#include"BinaryNode.h"
template<class Comparable>
BinaryNode<Comparable> * BinaryNode<Comparable>::duplicate()
{
BinaryNode<Comparable> *root=new BinaryNode<Comparable>(element);
if(left != NULL)
root->left=left->duplicate();
if(right != NULL)
root->right=right->duplicate();
return root;
}
template <class Comparable>
int BinaryNode<Comparable>::size(BinaryNode<Comparable> *t)
{
if(t==NULL)
return 0;
else
return 1+ size(t->left) + size(t->right);
}

template <class Comparable>
int BinaryNode<Comparable>::height(BinaryNode<Comparable> *t)
{
if(t==NULL)
return -1;
else
return 1 + max( height(t->left) + height(t->right));
}
template<class Comparable>
void BinaryNode<Comparable>::printPreOrder()
{
cout<<element<<endl;
if(left !=NULL)
left->printPreOrder();
if(right !=NULL)
right->printPreOrder();

}
template<class Comparable>
void BinaryNode<Comparable>::printPostOrder()
{
if(left !=NULL)
left->printPostOrder();
if(right !=NULL)
right->printPostOrder();
cout<<element<<endl;
}
template<class Comparable>
void BinaryNode<Comparable>::printInOrder()
{
if(left !=NULL)
left->printInOrder();
cout<<element<<endl;
if(right !=NULL)
right->printInOrder();

}





#ifndef BINARY_TREE_H_
#define BINARY_TREE_H_
#include"BinaryNode.cpp"
#include<iostream>
using namespace std;
#include<string>
// template <class Comparable>
// class BinaryNode;

template <class Comparable>
class BinaryTree
{
public:
BinaryTree():root(NULL){}
BinaryTree(const Comparable & rootItem)
:root(new Node(rootItem)){}
BinaryTree(const BinaryTree & rhs)
:root(NULL){*this = rhs;}
~BinaryTree(){
makeEmpty();
}

const BinaryTree & operator= (const BinaryTree & rhs);
void printPreOrder()
{if (root !=NULL) root->printPreOrder();}
void printInOrder()
{if (root !=NULL) root->printInOrder();}
void printPostOrder()
{if (root !=NULL) root->printPostOrder();}
void makeEmpty()
{makeEmpty(root);}
bool isEmpty()
{
return root ==NULL;
}
int size()
{return Node::size(root);}
int height()
{return Node::height(root);}
void merge(const Comparable & rootItem,BinaryTree &t1,BinaryTree &t2);
typedef BinaryNode<Comparable> Node;
Node *root;
void makeEmpty(Node * & t);

};
#endif




#include"BinaryTree.h"
template<class Comparable>
const BinaryTree<Comparable> &
BinaryTree<Comparable>::operator=(const BinaryTree<Comparable> & rhs)
{
if(this != &rhs)
{
makeEmpty();
if(rhs.root != NULL)
root = rhs.root->duplicate();
}
return *this;
}
template <class Comparable>
void BinaryTree<Comparable>::makeEmpty(BinaryNode<Comparable> * & t)
{
if( t!=NULL)
{
makeEmpty(t->left);
makeEmpty(t->right);
delete t;
t=NULL;
}
}






#ifndef BINARY_SEARCH_TREE_H_
#define BINARY_SEARCH_TREE_H_
#include"BinaryNode.cpp"
// #include"BinaryTree.cpp"
#include <iostream> // For NULL
using namespace std;
#include<string>
// Binary node and forward declaration because g++ does
// not understand nested classes.
/* template <class Comparable>
class BinarySearchTree;
template <class Comparable>
class BinaryTree;
template <class Comparable>
*/
// BinarySearchTree class
//
// CONSTRUCTION: with ITEM_NOT_FOUND object used to signal failed finds
//
// ******************PUBLIC OPERATIONS*********************
// void insert( x ) --> Insert x
// void remove( x ) --> Remove x
// Comparable find( x ) --> Return item that matches x
// Comparable findMin( ) --> Return smallest item
// Comparable findMax( ) --> Return largest item
// boolean isEmpty( ) --> Return true if empty; else false
// void makeEmpty( ) --> Remove all items
// void printTree( ) --> Print tree in sorted order
template <class Comparable>
class BinarySearchTree
{
public:
explicit BinarySearchTree( const Comparable & notFound );
BinarySearchTree( const BinarySearchTree & rhs );
~BinarySearchTree( );
const Comparable & findMin( ) const;
const Comparable & findMax( ) const;
const Comparable & find( const Comparable & x ) const;
bool isEmpty( ) const;
void printTree( ) const;
void makeEmpty( );
void insert( const Comparable & x );
void remove( const Comparable & x );
const BinarySearchTree & operator=( const BinarySearchTree & rhs );
BinaryNode<Comparable> *root;
const Comparable ITEM_NOT_FOUND;
const Comparable & elementAt( BinaryNode<Comparable> *t ) const;
void insert( const Comparable & x, BinaryNode<Comparable> * & t ) const;
void remove( const Comparable & x, BinaryNode<Comparable> * & t ) const;
BinaryNode<Comparable> * findMin( BinaryNode<Comparable> *t ) const;
BinaryNode<Comparable> * findMax( BinaryNode<Comparable> *t ) const;
BinaryNode<Comparable> * find( const Comparable & x, BinaryNode<Comparable> *t ) const;
void makeEmpty( BinaryNode<Comparable> * & t ) const;
void printTree( BinaryNode<Comparable> *t ) const;
BinaryNode<Comparable> * clone( BinaryNode<Comparable> *t ) const;
};
#endif




#include "BinarySearchTree.h"
/**
* Implements an unbalanced binary search tree.
* Note that all "matching" is based on the < method.
*/

/**
* Construct the tree.
*/
template <class Comparable>
BinarySearchTree<Comparable>::BinarySearchTree( const Comparable & notFound ) :
root( NULL ), ITEM_NOT_FOUND( notFound )
{
}

/**
* Copy constructor.
*/
template <class Comparable>
BinarySearchTree<Comparable>::
BinarySearchTree( const BinarySearchTree<Comparable> & rhs ) :
root( NULL ), ITEM_NOT_FOUND( rhs.ITEM_NOT_FOUND )
{
*this = rhs;
}

/**
* Destructor for the tree.
*/
template <class Comparable>
BinarySearchTree<Comparable>::~BinarySearchTree( )
{
makeEmpty( );
}

/**
* Insert x into the tree; duplicates are ignored.
*/
template <class Comparable>
void BinarySearchTree<Comparable>::insert( const Comparable & x )
{
insert( x, root );
}

/**
* Remove x from the tree. Nothing is done if x is not found.
*/
template <class Comparable>
void BinarySearchTree<Comparable>::remove( const Comparable & x )
{
remove( x, root );
}


/**
* Find the smallest item in the tree.
* Return smallest item or ITEM_NOT_FOUND if empty.
*/
template <class Comparable>
const Comparable & BinarySearchTree<Comparable>::findMin( ) const
{
return elementAt( findMin( root ) );
}

/**
* Find the largest item in the tree.
* Return the largest item of ITEM_NOT_FOUND if empty.
*/
template <class Comparable>
const Comparable & BinarySearchTree<Comparable>::findMax( ) const
{
return elementAt( findMax( root ) );
}

/**
* Find item x in the tree.
* Return the matching item or ITEM_NOT_FOUND if not found.
*/
template <class Comparable>
const Comparable & BinarySearchTree<Comparable>::
find( const Comparable & x ) const
{
return elementAt( find( x, root ) );
}

/**
* Make the tree logically empty.
*/
template <class Comparable>
void BinarySearchTree<Comparable>::makeEmpty( )
{
makeEmpty( root );
}

/**
* Test if the tree is logically empty.
* Return true if empty, false otherwise.
*/
template <class Comparable>
bool BinarySearchTree<Comparable>::isEmpty( ) const
{
return root == NULL;
}

/**
* Print the tree contents in sorted order.
*/
template <class Comparable>
void BinarySearchTree<Comparable>::printTree( ) const
{
if( isEmpty( ) )
cout << "Empty tree" << endl;
else
printTree( root );
}
/*
// added
//print preorder
template <class Comparable>
void BinarySearchTree<Comparable>::printpre( ) const
{
if( isEmpty( ) )
cout << "Empty tree" << endl;
else
printpre( root );
}
//
*/
/**
* Deep copy.
*/
template <class Comparable>
const BinarySearchTree<Comparable> &
BinarySearchTree<Comparable>::
operator=( const BinarySearchTree<Comparable> & rhs )
{
if( this != &rhs )
{
makeEmpty( );
root = clone( rhs.root );
}
return *this;
}

/**
* Internal method to get element field in node t.
* Return the element field or ITEM_NOT_FOUND if t is NULL.
*/
template <class Comparable>
const Comparable & BinarySearchTree<Comparable>::
elementAt( BinaryNode<Comparable> *t ) const
{
if( t == NULL )
return ITEM_NOT_FOUND;
else
return t->element;
}

/**
* Internal method to insert into a subtree.
* x is the item to insert.
* t is the node that roots the tree.
* Set the new root.
*/
template <class Comparable>
void BinarySearchTree<Comparable>::
insert( const Comparable & x, BinaryNode<Comparable> * & t ) const
{
if( t == NULL )
t = new BinaryNode<Comparable>( x, NULL, NULL );
else if( x < t->element )
insert( x, t->left );
else if( t->element < x )
insert( x, t->right );
else
; // Duplicate; do nothing
}

/**
* Internal method to remove from a subtree.
* x is the item to remove.
* t is the node that roots the tree.
* Set the new root.
*/
template <class Comparable>
void BinarySearchTree<Comparable>::
remove( const Comparable & x, BinaryNode<Comparable> * & t ) const
{
if( t == NULL )
return; // Item not found; do nothing
if( x < t->element )
remove( x, t->left );
else if( t->element < x )
remove( x, t->right );
else if( t->left != NULL && t->right != NULL ) // Two children
{
t->element = findMin( t->right )->element;
remove( t->element, t->right );
}
else
{
BinaryNode<Comparable> *oldNode = t;
t = ( t->left != NULL ) ? t->left : t->right;
delete oldNode;
}
}

/**
* Internal method to find the smallest item in a subtree t.
* Return node containing the smallest item.
*/
template <class Comparable>
BinaryNode<Comparable> *
BinarySearchTree<Comparable>::findMin( BinaryNode<Comparable> *t ) const
{
if( t == NULL )
return NULL;
if( t->left == NULL )
return t;
return findMin( t->left );
}

/**
* Internal method to find the largest item in a subtree t.
* Return node containing the largest item.
*/
template <class Comparable>
BinaryNode<Comparable> *
BinarySearchTree<Comparable>::findMax( BinaryNode<Comparable> *t ) const
{
if( t != NULL )
while( t->right != NULL )
t = t->right;
return t;
}

/**
* Internal method to find an item in a subtree.
* x is item to search for.
* t is the node that roots the tree.
* Return node containing the matched item.
*/
template <class Comparable>
BinaryNode<Comparable> *
BinarySearchTree<Comparable>::
find( const Comparable & x, BinaryNode<Comparable> *t ) const
{
if( t == NULL )
return NULL;
else if( x < t->element )
return find( x, t->left );
else if( t->element < x )
return find( x, t->right );
else
return t; // Match
}

/**
* Internal method to make subtree empty.
*/
template <class Comparable>
void BinarySearchTree<Comparable>::
makeEmpty( BinaryNode<Comparable> * & t ) const
{
if( t != NULL )
{
makeEmpty( t->left );
makeEmpty( t->right );
delete t;
}
t = NULL;
}

/**
* Internal method to print a subtree rooted at t in sorted order.
*/
template <class Comparable>
void BinarySearchTree<Comparable>::printTree( BinaryNode<Comparable> *t ) const
{
if( t != NULL )
{
cout << t->element << endl;
printTree( t->left );
// cout << t->element << endl;
printTree( t->right );
}
}
/*
//////////////////////////////////////// added
template <class Comparable>
void BinarySearchTree<Comparable>::printpre( BinaryNode<Comparable> *t ) const
{
if( t != NULL )
{
cout << t->element << endl;
printpre( t->left );
printpre( t->right );
}
}
/////////////////////////////////
*/
/**
* Internal method to clone subtree.
*/
template <class Comparable>
BinaryNode<Comparable> *
BinarySearchTree<Comparable>::clone( BinaryNode<Comparable> * t ) const
{
if( t == NULL )
return NULL;
else
return new BinaryNode<Comparable>( t->element, clone( t->left ), clone( t->right ) );
}







#include "BinarySearchTree.cpp"

// Test program
int main( )
{
const int ITEM_NOT_FOUND = -9999;
BinarySearchTree<int> t( ITEM_NOT_FOUND );
int NUMS = 4000;
const int GAP = 37;
int i;
/*
// added
BinarySearchTree<int> deneme(20);
deneme.insert(12);
deneme.insert(-21);
deneme.insert(-44);
deneme.insert(22);
deneme.insert(24);
deneme.insert(23);
deneme.insert(14);
deneme.printTree();
cout<<" "<<endl;

cout<<deneme.find(12)<<endl;
cout<<deneme.findMin()<<endl;
cout<<deneme.findMax()<<endl;

*/

//
cout << "Checking... (no more output means success)" << endl;

for( i = GAP; i != 0; i = ( i + GAP ) % NUMS )
t.insert( i );

for( i = 1; i < NUMS; i+= 2 )
t.remove( i );

if( NUMS < 40 )
t.printTree( );
if( t.findMin( ) != 2 || t.findMax( ) != NUMS - 2 )
cout << "FindMin or FindMax error!" << endl;

for( i = 2; i < NUMS; i+=2 )
if( t.find( i ) != i )
cout << "Find error1!" << endl;

for( i = 1; i < NUMS; i+=2 )
{
if( t.find( i ) != ITEM_NOT_FOUND )
cout << "Find error2!" << endl;
}

BinarySearchTree<int> t2( ITEM_NOT_FOUND );
t2 = t;

for( i = 2; i < NUMS; i+=2 )
if( t2.find( i ) != i )
cout << "Find error1!" << endl;

for( i = 1; i < NUMS; i+=2 )
{
if( t2.find( i ) != ITEM_NOT_FOUND )
cout << "Find error2!" << endl;
}


return 0;
}

[acehreli]

code bolumlerini kapatmak icin \code degil, /code kullanmak gerekiyor; duzelttim...

Hata mesajini neden soylemiyorsun?

Ali

[Lewissi]

hatalar:


TestBinarySearchTree.cpp: In function `int main()':
TestBinarySearchTree.cpp:13: error: request for member `insert' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'
TestBinarySearchTree.cpp:14: error: request for member `insert' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'
TestBinarySearchTree.cpp:15: error: request for member `insert' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'
TestBinarySearchTree.cpp:16: error: request for member `insert' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'
TestBinarySearchTree.cpp:17: error: request for member `insert' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'
TestBinarySearchTree.cpp:18: error: request for member `insert' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'
TestBinarySearchTree.cpp:19: error: request for member `insert' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'
TestBinarySearchTree.cpp:20: error: request for member `printTree' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'
TestBinarySearchTree.cpp:23: error: request for member `find' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'
TestBinarySearchTree.cpp:24: error: request for member `findMin' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'
TestBinarySearchTree.cpp:25: error: request for member `findMax' in `deneme',
which is of non-aggregate type `BinarySearchTree<int> ()()'

[acehreli]

O hatalari aldigin sirada deneme'nin parantezlerinin icinde 20 var miydi? Eger yok idiyse, yani soyle yazdiysan:

BinarySearchTree<int> deneme();

O satirin anlami C++ yaziminin bir talihsizligi nedeniyle "deneme, hicbir parametre almayan ve BinarySearchTree<int> dOndUren bir islevdir" oluyor.

Derleyici aslinda bunu soyluyor ama C ve C++ yazimlari karisik oldugu icin zor anlasiliyor. deneme'nin tUrU olarak ne dusundugune bak:

BinarySearchTree<int> ()()

Sondaki parantezler parametre almayan bir islev olduguna bir isaret. Onlardan onceki parantez cifti de deneme'nin bir islev oldugunu gosteriyor. BinarySearchTree<int> de dOnUs turu tabii.

Ama eger 20 kullandiginda da o hatalari aldiysan beni asar :)

Eger parametre kullanilmayacaksa soyle yazmak gerekiyor:

BinarySearchTree<int> deneme;

Ali

[Lewissi]

parantez icine 20 yazarsam hata almiyor ama insert fonksiyonu calismiyor :( . varsayIlan deger olarak 0 oluyor o nodelar. nedeni nedir?

[Lewissi]

test dosyasinda bazi cout ifadeleri koydum ve garip seyler oldu. nedenini anlamadim. asagida kodun icinde yorum satirlari koydum. bunlar neden oluyor?


#include "BinarySearchTree.cpp"

// Test program
int main( )
{
const int ITEM_NOT_FOUND = -9999;
BinarySearchTree<int> t( ITEM_NOT_FOUND );
int NUMS = 4000;
const int GAP = 37;
int i;
// added
BinarySearchTree<int> deneme(20);
deneme.remove(20);
deneme.printTree();
cout<<endl<<"hebe"<<endl;
int dum;
dum=getchar();
deneme.insert(12);
deneme.insert(-21);
deneme.insert(-44);
deneme.insert(22);
deneme.insert(24);
deneme.insert(23);
deneme.insert(14);
deneme.printTree();
cout<<" printtree "<<endl;
cout<<deneme.find(12)<<endl;// !!!! ekrana 20 basiyor!!!
cout<<"find12"<<endl;
cout<<deneme.findMin()<<endl;
cout<<"findmin"<<endl;
cout<<deneme.findMax()<<endl;
cout<<"findmax"<<endl;
int c;
cout<<"heeeee"<<endl;
c=getchar();// !!!!atliyor bunu. ben input girmeden devam ediyor !!!!
cout<<"hwwwwww"<<endl;
cout<<"hyyyyy"<<endl;
c=getchar();
//

cout << "Checking... (no more output means success)" << endl;

// int ci;
// cout<<"haaaa"<<endl;
// ci=getchar();

for( i = GAP; i != 0; i = ( i + GAP ) % NUMS )
t.insert( i );
/*
//int ac;
//cout<<"hqqqqqqqq"<<endl;
// ac=getchar();
*/
for( i = 1; i < NUMS; i+= 2 )
t.remove( i );
/*
* int vc;
cout<<"hffffff"<<endl;
vc=getchar();
*/
if( NUMS < 40 )
t.printTree( );
if( t.findMin( ) != 2 || t.findMax( ) != NUMS - 2 )
cout << "FindMin or FindMax error!" << endl;
// cout<<" bir "<<endl;
/*
int c1;
c1=getchar();
*/
for( i = 2; i < NUMS; i+=2 )
if( t.find( i ) != i )
cout << "Find error1!" << endl;
/*
cout<<" iki "<<endl;
int c2;
c2=getchar();
*/
for( i = 1; i < NUMS; i+=2 )
{
if( t.find( i ) != ITEM_NOT_FOUND )
cout << "Find error2!" << endl;
}

BinarySearchTree<int> t2( ITEM_NOT_FOUND );
t2 = t;
/*
cout<<" uc "<<endl;
int c3;
c3=getchar();
*/
for( i = 2; i < NUMS; i+=2 )
if( t2.find( i ) != i )
cout << "Find error1!" << endl;
/*
cout<<" dort "<<endl;
int c4;
c4=getchar();
*/
for( i = 1; i < NUMS; i+=2 )
{
if( t2.find( i ) != ITEM_NOT_FOUND )
cout << "Find error2!" << endl;
}
/*
int c5;
c5=getchar();
*/
// cout<<" bitti "<<endl;
return 0;
}

[Lewissi]

sorunu hallettim.

[acehreli]

Bize de soyler misin... Tesekkurler...

Ali

[Lewissi]

yukaridaki hatanin nedeni:
BinaryNode classInIn constructorI eksik tanImlanmI$.

AMA yine bu dosyalari include ettigim asagidaki dosyada hata aliyorum. bu link hatalarInI nasIl duzeltirim?
g++ da aldigim hatalar:

/tmp/ccnmY2Ec.o: In function `sokAl(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >)':
carsamba.cpp:(.text+0x0): multiple definition of `sokAl(std::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::basic_string<char, std::char_traits<char>, std::allocator<char> >, int, std::basic_string<char, std::char_traits<char>, std::allocator<char> >)'
/tmp/ccEf6jkt.o:yukaridakiler.cpp:(.text+0x0): first defined here
/tmp/ccnmY2Ec.o: In function `cevir_lower(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)':
carsamba.cpp:(.text+0x190): multiple definition of `cevir_lower(std::basic_string<char, std::char_traits<char>, std::allocator<char> >)'
/tmp/ccEf6jkt.o:yukaridakiler.cpp:(.text+0x190): first defined here
collect2: ld returned 1 exit status



#include"yukaridakiler.cpp"

// #include <iostream> // For NULL

// using namespace std;

// #include<string>

// List class

//

// CONSTRUCTION: with no initializer

// Access is via ListItr class

//

// ******************PUBLIC OPERATIONS*********************

// boolean isEmpty( ) --> Return true if empty; else false

// void makeEmpty( ) --> Remove all items

// ListItr zeroth( ) --> Return position to prior to first

// ListItr first( ) --> Return first position

// void insert( x, p ) --> Insert x after current iterator position p

// void remove( x ) --> Remove x

// ListItr find( x ) --> Return position that views x

// ListItr findPrevious( x )

// --> Return position prior to x

// ******************ERRORS************************** ******

// No special errors



template <class Object>

class List; // Incomplete declaration.



template <class Object>

class ListItr; // Incomplete declaration.





template <class Object>

class List

{

public:

List( );

List( const List & rhs );

~List( );



bool isEmpty( ) const;

void makeEmpty( );

ListItr<Object> zeroth( ) const;

ListItr<Object> first( ) const;

void insert( const Object & x, const ListItr<Object> & p );

ListItr<Object> find( const Object & x ) const;

ListItr<Object> findPrevious( const Object & x ) const;

void remove( const Object & x );



const List & operator=( const List & rhs );



BinaryNode<Object> *header;

};





// ListItr class; maintains "current position"

//

// CONSTRUCTION: Package friendly only, with a ListNode

//

// ******************PUBLIC OPERATIONS*********************

// bool isPastEnd( ) --> True if past end position in list

// void advance( ) --> Advance (if not already null)

// Object retrieve --> Return item in current position



template <class Object>

class ListItr

{

public:

ListItr( ) : current( NULL ) { }

bool isPastEnd( ) const

{ return current == NULL; }

void advance( )

{ if( !isPastEnd( ) ) current = current->right; }

const Object & retrieve( ) const

{

return current->element; }



private:

BinaryNode<Object> *current; // Current position



ListItr( BinaryNode<Object> *theNode )

: current( theNode ) { }



friend class List<Object>; // Grant access to constructor

};







/**

* Construct the list

*/

template <class Object>

List<Object>::List( )

{

header = new BinaryNode<Object>;

}



/**

* Copy constructor

*/

template <class Object>

List<Object>::List( const List<Object> & rhs )

{

header = new BinaryNode<Object>;

*this = rhs;

}



/**

* Destructor

*/

template <class Object>

List<Object>::~List( )

{

makeEmpty( );

delete header;

}



/**

* Test if the list is logically empty.

* return true if empty, false otherwise.

*/

template <class Object>

bool List<Object>::isEmpty( ) const

{

return header->right == NULL;

}



/**

* Make the list logically empty.

*/

template <class Object>

void List<Object>::makeEmpty( )

{

while( !isEmpty( ) )

remove( first( ).retrieve( ) );

}



/**

* Return an iterator representing the header node.

*/

template <class Object>

ListItr<Object> List<Object>::zeroth( ) const

{

return ListItr<Object>( header );

}



/**

* Return an iterator representing the first node in the list.

* This operation is valid for empty lists.

*/

template <class Object>

ListItr<Object> List<Object>::first( ) const

{

return ListItr<Object>( header->right);

}



/**

* Insert item x after p.

*/

template <class Object>

void List<Object>::insert( const Object & x, const ListItr<Object> & p )

{

if( p.current != NULL )

p.current->right = new BinaryNode<Object>( x, p.current->right );

}



/**

* Return iterator corresponding to the first node containing an item x.

* Iterator isPastEnd if item is not found.

*/

template <class Object>

ListItr<Object> List<Object>::find( const Object & x ) const

{

/* 1*/ BinaryNode<Object> *itr = header->right;



/* 2*/ while( itr != NULL && itr->element != x )

/* 3*/ itr = itr->right;



/* 4*/ return ListItr<Object>( itr );

}



/**

* Return iterator prior to the first node containing an item x.

*/

template <class Object>

ListItr<Object> List<Object>::findPrevious( const Object & x ) const

{

/* 1*/ BinaryNode<Object> *itr = header;



/* 2*/ while( itr->right!= NULL && itr->right ->element != x )

/* 3*/ itr = itr->right;



/* 4*/ return ListItr<Object>( itr );

}



/**

* Remove the first occurrence of an item x.

*/

template <class Object>

void List<Object>::remove( const Object & x )

{

ListItr<Object> p = findPrevious( x );



if( p.current->right != NULL )

{

BinaryNode<Object> *oldNode = p.current->right;

p.current->right = p.current->right->right; // Bypass deleted node

delete oldNode;

}

}



/**

* Deep copy of linked lists.

*/

template <class Object>

const List<Object> & List<Object>::operator=( const List<Object> & rhs )

{

ListItr<Object> ritr = rhs.first( );

ListItr<Object> itr = zeroth( );



if( this != &rhs )

{

makeEmpty( );

for( ; !ritr.isPastEnd( ); ritr.advance( ), itr.advance( ) )

insert( ritr.retrieve( ), itr );

}

return *this;

}





// Simple print method

template <class Object>

void printList( const List<Object> & theList )

{

if( theList.isEmpty( ) )

cout << "Empty list" << endl;

else

{

ListItr<Object> itr = theList.first( );

for( ; !itr.isPastEnd( ); itr.advance( ) )

cout << itr.retrieve( ) << " ";

}



cout << endl;

}


///// carsamba
class degisken{
public:
string name;
string scope;
string type;
degisken(string itsName="someName",string itsScope="someScope", string itsType="someType"){
name=itsName;
scope=itsScope;
type=itsType;
}

degisken(){
name="someName";
scope="someScope";
type="someType";
}
~degisken(){}

};
/*
bool isMember(string aranan,vector<string>aranilan)
{
for(int i=0;i<aranilan.size();i++)
{
if( strstr( ((aranilan.at(i)).c_str()),aranan.c_str()) != NULL)
return true;
else continue;
}
return false;
}
void getvariables(vector<degisken> vec_var,ifstream in_dos){
string ss;
getline (in_dos,ss);
if(! (in_dos.eof()))
{
if (ss )

}

}
*/
//
string getVarLine(string line,vector<degisken> global_var,string dum)
{
char array[line.size()];
for(int w=0;w<line.size();w++)
array[w]=line.at(w);
char *cp=array;
char *kontrol;
degisken temp33;
string adi="",tipi="";
string t="";
if (sokAl(line,"function",8,dum) == "yanlis" &&
sokAl(line,"type",4,dum) == "yanlis" &&
sokAl(line,"{",1,dum) == "yanlis" &&
sokAl(line,"}",1,dum) == "yanlis"
)
{

for( ;*cp != ' ';cp++)
{
t += *cp;
}
tipi=t;
cp++;
while(*cp != ';'){
for( ;*cp != ' ';cp++)
{
adi += *cp;
}
temp33(adi,"GLOBAL",tipi);
global_var.push_back(temp33);
kontrol=cp+1;
if(*kontrol == ';')
break;
else cp+3;
}
}
}


int main () {
string raw_line;
ifstream raw_file("raw3.txt");
ofstream lower_file("lower3.txt");
if (raw_file.is_open() && lower_file.is_open()){
while (! raw_file.eof())
{getline (raw_file,raw_line);
if(! (raw_line.empty())){
lower_file<<cevir_lower(raw_line)<<endl; }}}
raw_file.close();
lower_file.close();
string r;
string al;
vector<string>read_types;
vector<string>read_variables;
vector<string>read_functions;
string line,type;
ifstream myfile ("lower3.txt");
if (myfile.is_open())
{
while (! myfile.eof())
{getline (myfile,line);
if(! (line.empty()))
{
if( sokAl(line,"type",4,r) != "yanlis")
{
read_types.push_back(sokAl(line,"type",4,r) );
}
}
}
for(int y=0;y<read_types.size();y++)
{cout<<read_types.at(y)<<endl;
}
}
string bosluk=" ";
string satir,functions;
ifstream func_file ("lower3.txt");
if (func_file.is_open())
{
while (! func_file.eof())
{getline (func_file,satir);
if(! (satir.empty()))
{
if( sokAl(satir,"function",8,r) != "yanlis")
{read_functions.push_back(" " + sokAl(satir,"function",8,r) + " ");
}}}
}
/*
string satirva
ifstream ifs ("lower3.txt");
if (ifs.is_open())
{
while (! ifs.eof())
{getline (ifs,satirva);
if(! (satirva.empty()))
{
if( sokAl(satirva,"type",4,r) == "yanlis"
&&
sokAl(satirva,"function",8,r) == "yanlis"
)
{read_functions.push_back(" " + sokAl(satirva,"f",,r) + " ");/////////////////////////////burda
}}}
}

*/

/*
BinarySearchTree<int> deneme(20);
deneme.insert(12);
deneme.insert(10);
deneme.insert(22);
deneme.insert(1);
deneme.printTree();
*/
return 0;
}

[Lewissi]

bu sefer de duzelttim. aynı dosyaya koydum hepsini. ama bi turlu anlamadim bu garip hatalarin nedenini. genelde template kullanInca oluyor.

[acehreli]

Baglayici sokAl ve cevir_lower icin birden fazla tanim bulmus. Eger tanimlar herhangi bir sekilde programi olusturan iki .o dosyasi icinde bulunuyorsa; bu hata alinir.

Ornegin sokAl islevini bir baslik dosyasinda tanimlamissindir; o basligi iki .cpp dosyasina ekleyince sokAl'in tanimi iki .o dosyasi icine derlenmis olur. Baglayici da iki tane tanim gorur.

Ali