I'm trying to write a linked list of Node objects, where each Node contains: a string - data, and a pointer - next. To manage the list (e.g: add/remove nodes), I have Node objects: head, curr and temp. I'm trying to work out how to link up each node to the previous one when new data is added to the list, but I am having trouble doing so. The error is occuring in Node.cpp when I am trying to link the new node n to the curr nodes next pointer.
LinkedList.cpp:
#include <iostream>
#include <cstdlib>
#include "LinkedList.h"
#include "Node.h"
using namespace std;
LinkedList::LinkedList(value_type setData) {
head.setData(setData);
cout << head.getData() << endl;
}
void LinkedList::addNode(value_type addData) {
Node n;
n.setData(addData);
if (head.getData() != "") {
curr = head;
while(curr.getNext() != NULL) {
//Still writing this..
}
curr.setNext(n); //Is this correct?
}
else {
head = n;
}
}
LinkedList.h:
#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include "Node.h"
class LinkedList {
public:
typedef std::string value_type;
LinkedList();
LinkedList(value_type setData);
void addNode(value_type addData);
private:
Node head;
Node curr;
Node temp;
};
#endif
Node.cpp:
#include <iostream>
#include <cstdlib>
#include "Node.h"
using namespace std;
Node::Node() {
data = "";
next = NULL;
}
void Node::setData(value_type setData) {
data = setData;
}
string Node::getData() {
return data;
}
void setNext(Node n) {
next = n; //'next' was not declared in this scope error.
//Does this assignment statement even work in this scenario?
}
Node * Node::getNext() {
return next;
}
Node.h:
#ifndef NODE_H
#define NODE_H
class Node {
private:
typedef std::string value_type;
value_type data;
Node* next;
public:
Node();
void setData(value_type setData);
value_type getData();
void setNext(Node n);
Node * getNext();
};
#endif
Any help would be greatly appreciated, thanks guys.
You've got this line:
void setNext(Node n) {
You probably want this instead:
void Node::setNext(Node n) {
The function void setNext(Node n); is declared in class Node. So in Node.cpp, you must define the function with void Node::setNext(Node n);. The symbol :: will show the function's scope.
Related
I've been looking around and haven't seen a question with a problem as specific as this one.
I'm trying to create a linked list in this program, but I get a runtime error and no build errors when I run it.
Main:
#include <iostream>
#include "LinkedListInterface.h"
#include "LinkedList.h"
#include <fstream>
int main(int argc, char * argv[])
{
ifstream in(argv[1]);
LinkedList<int> myIntList;
}
LinkedList class:
#ifndef LINKED_LIST_H
#define LINKED_LIST_H
#include <string>
#include <sstream>
using namespace std;
template<typename T>
class LinkedList : public LinkedListInterface<T>
{
public:
LinkedList()
{
head->next = NULL;
}
private:
struct Node
{
T data;
struct Node *next;
};
Node *head;
};
I have assured that the problem is not with an out-of-bounds error on argv[1], and removing any of the statements in LinkedList() or main() makes the program run smoothly.
You have to construct head before invoking head->next = NULL. But this would mean that there is an empty node in the list when you create it.
template<typename T>
class LinkedList : public LinkedListInterface<T>
{
public:
LinkedList()
{
// At least do this
head = new Node();
head->next = NULL;
// The best idea is to do below:
// head = null;
}
private:
struct Node
{
T data;
struct Node *next;
};
Node *head;
};
I am implementing bptree using c++. I am am stuck in the initial step of node creation. Keep getting "C2011 'Node':'class' type redefinition" error. I found some suggestions online to remove class key word from cpp file. But when I remove class keyword I get lots of other errors. here is my code for Node.cpp:
#include "Node.h"
#include <cstdio>
#include <iostream>
#include <string>
#include <map>
using namespace std;
class Node {
bool leaf;
Node** kids;
map<int, string> value;
int keyCount;//number of current keys in the node
//constructor;
Node::Node(int order) {
this->value = {};
this->kids = new Node *[order + 1];
this->leaf = true;
this->keyCount = 0;
for (int i = 0; i < (order + 1); i++) {
this->kids[i] = NULL;
}
}
};
and Node.h file is as following:
#pragma once
#ifndef NODE_HEADER
#define NODE_HEADER
class Node {
public:
Node(int order) {};
};
#endif
How can I fix this?
Problem
In C++, headers are simply pasted into the body when you #include. So now the compiler sees:
class Node {
public:
Node(int order) {};
};
// stuff from system headers omitted for brevity
using namespace std;
class Node {
bool leaf;
//...
};
There are two problems here:
compiler sees class Node twice with different bodies.
Node::Node is defined twice (first time empty {}).
Solution
The header should include class declaration:
#include <map>
using namespace std;
class Node {
bool leaf;
Node** kids;
map<int, string> value;
int keyCount;//number of current keys in the node
//constructor;
Node(int order);
};
Note that the constructor has no body here. It's just a declaration. Because it uses map you need to include <map> and add using namespace before the declaration.
After that don't put class Node again in the .cpp or .cc file. Only put the method implementations at the top level:
Node::Node(int order) {
// ...
}
I'm having a bit of trouble trying to create a linked list that uses a LinkedList and Node class. In the List class, how do I create the head, curr and temp objects? I thought I could just initialise them as objects, which would then call the default Node() constructor and assign them a data and pointer variable. But I am getting the error: ‘Node’ does not name a type and ‘head’ was not declared in this scope for the objects head, curr and temp.
Here's my code:
LinkedList.cpp:
#include <iostream>
#include <cstdlib>
#include "LinkedList.h"
#include "Node.h"
using namespace std;
LinkedList::LinkedList() {
head = NULL;
curr = NULL;
temp = NULL;
cout << "Blank list created." << endl;
}
LinkedList::LinkedList(value_type addData) {
Node n(addData);
}
LinkedList.h:
class LinkedList {
public:
typedef std::string value_type;
LinkedList();
LinkedList(value_type addData);
private:
Node head;
Node curr;
Node temp;
};
Node.cpp:
#include <iostream>
#include <cstdlib>
#include "Node.h"
using namespace std;
Node::Node() {
nodePtr n = new node;
n->next = NULL;
n->data = NULL;
}
Node::Node(value_type addData) {
nodePtr n = new node;
n->next = NULL;
n->data = addData;
}
Node.h:
class Node {
public:
typedef std::string value_type;
Node();
Node(value_type addData);
private:
struct node {
value_type data;
node* next;
};
typedef struct node* nodePtr;
};
Any help would be greatly appreciated, thanks guys!
Look at what the compiler does with LinkedList.c. It starts with this:
...
#include "LinkedList.h"
#include "Node.h"
...
Then it evaluates the #include directives, and pulls LinkedList.h and Node.h into the source:
...
class LinkedList {
...
Node head;
Node curr;
Node temp;
};
class Node {
...
};
Then it tries to compile this, gets as far as "Node head;" (when it has not yet reached the declaration of the class Node), and complains that it doesn't know what you're talking about.
The file that declares class LinkedList needs to know what a Node is. Put #include "Node.h" near the top of LinkedList.h (and add header guards to Node.h) and you won't have this problem.
I have created a link list program that performs several functions. I've written a function to destroy the list that takes "top" as a parameter. I eventually use this function in my destructor. Can I actually test this?
Here is my shortened Family.h:
#ifndef FAMILY_H
#define FAMILY_H
#include<string>
using namespace std;
#include "Child.h"
#include "Wife.h"
#include "Husband.h"
class Family
{
protected:
HusPtr top;
void Destroy(HusPtr& top); //I know in order to access this in the Main, I'd have to make
//this Public. But I'd have to create a local pointer named top.
//Because the local pointer points to nothing, I get a segmentation
//fault.
public:
Family();
Family(HusPtr& h);
Family(const Family& source);
~Family();
};
#endif
Here is my Destroy function in my Family.cpp:
void Family::Destroy(HusPtr& top)
{
HusPtr curr = top;
WifePtr w = curr->myWife;
while(curr != NULL)
{
if(curr->myWife != NULL)
{
while(w->myChildren != NULL)
{
ChildPtr c = w->myChildren;
ChildPtr cNext = c->mySibling;
w->myChildren = cNext;
delete c;
}
curr->myWife = NULL;
delete w;
}
HusPtr next = curr;
curr = next->nextFamily;
delete next;
top = curr;
}
}
My Main.cpp:
using namespace std;
#include "Family.h"
HusPtr top; //points to nothing.
int main()
{
Family F1;
F1.ProcessTransaction("transaction.txt");
F1.Destroy(top);// gives a segmentation fault...likely due to the fact that top points to nothing.
}
Wife.h:
#ifndef HUSBAND_H
#define HUSBAND_H
#include<string>
using namespace std;
#include "Person.h"
class Husband;
typedef Husband* HusPtr;
class Wife;
typedef Wife* WifePtr;
class Husband:public Person
{
friend class Wife;
friend class Family;
protected:
HusPtr nextFamily;
WifePtr myWife;
public:
Husband();
Husband(long hSSN, string hFirst, string hLast);
void Print() const;
};
#endif
Wife.h:
#ifndef WIFE_H
#define WIFE_H
#include<string>
using namespace std;
#include "Person.h"
#include "Child.h"
class Child;
typedef Child* ChildPtr;
class Wife:public Person
{
friend class Family;
protected:
ChildPtr myChildren;
public:
Wife();
Wife(long wSSN, string wFirst, string wLast);
void Print() const;
};
#endif
Child.h:
#ifndef CHILD_H
#define CHILD_H
#include<string>
using namespace std;
#include "Person.h"
class Child;
typedef Child* ChildPtr;
class Child:public Person
{
friend class Family;
protected:
ChildPtr mySibling;
public:
Child();
Child(long cSSN, string cFirst, string cLast);
void Print() const;
};
#endif
This is not a needed function in this assignment, but I decided to implement it anyway. Everything maps out fine and should work, but I really think that the segmentation fault I receive is due to the fact that I'm passing a pointer created in Main.cpp that isn't pointing anywhere. Am I correct?
In second iteration after deleting w, you are not assigning it again. But you try to access its children again. so it get crashed.
in while loop
first iteration
...
delete w;
second iteration
w->children; program will be crashed.
#ifndef SLIST_H
#define SLIST_H
#include "llist.h"
using namespace std;
class slist:public llist{
public:
slist();
int search(el_t Key);
void replace(el_t Elem, int I);
};
#endif
That is my new class I just made that gives me the search and replace function, on top of all the inherited functions contained in llist.h
In my main...
#include "slist.h"
#include <iostream>
using namespace std;
int main(){
slist list;
list.addFront(4);
cout<<list.search(4);
}
I'm trying to call addfront() which is a public function in the llist class. Then I want to call search() which is an inherited public function of the slist class. g++ gives me a few errors that I don't understand.
slist.h: In function âint main()â:
slist.h:10: error: âslist::slist()â is protected
main.cpp:7: error: within this context
slist() is protected? Why's that? I put it under public:
Also whats up with the this context, I'm guessing I'm just doing the whole inheritance thing totally wrong. Any help would be appreciated!
Edit: Here's the llist class, if it helps
#ifndef LIST_H
#define LIST_H
#include <iostream>
using namespace std;
class llist{
protected:
typedef int el_t;
el_t total;
struct Node{
int Elem;
Node *Next;
};
Node *Front;
Node *Rear;
Node * Curr;
public:
class Overflow{};
class Underflow{};
class Range{};
llist();
~llist();
bool isEmpty();
void displayAll();
void addRear(el_t NewNum);
void deleteFront(el_t& OldNum);
void addFront(el_t NewNum);
void deleteRear(el_t& OldNum);
void deleteIth(int I, el_t& OldNum);
void addbeforeIth(int I, el_t newNum);
class Overflow;
};
#endif
This is llist.cpp with only the relevant functions pasted
#include "llist.h"
#include <iostream>
using namespace std;
int total=0;
llist::llist(){
Front=NULL;
Rear=NULL;
total=0;
}
llist::~llist(){
while(Front!=NULL){
int z;
deleteFront(z);
}
}
bool llist::isEmpty(){
if(Front==NULL){
return true;
}
return false;
}
void llist::displayAll(){
Curr=Front;
if(isEmpty()){
cout<<"[ empty ]"<<endl;
}else{
while(Curr!=NULL){\
cout<<"curr != NuL"<<endl;
cout<<Curr->Elem<<endl;
Curr=Curr->Next;
}
}
}
void llist::addFront(el_t NewNum){
if(isEmpty()){
Node *x=new Node;
x->Next=Front;
Rear=Front;
Front=x;
Front->Elem=NewNum;
}else{
Node *x=new Node;
x->Next=Front;
Front=x;
Front->Elem=NewNum;
++total;
}
}
I honestly can't see the problem but not every compiler is standard-compliant, so I would try the following:
1) Rename your class - if it works, that means it's a because of a naming conflict.
2) Remove the using directives.
3) Remove the inheritance. If it works after this... you really need to change compilers.
4) Try #undef public before your class declaration. If it works after this... well, someone's in for a talk with the manager.
5) Pray...