Errors: Redefinition of class and Previous Definition of class in C++ - c++

Question

When I try to run the class with the class counter.cpp, I get the following error
In file included from Bounded_Counter.h:7:0,
from counterApp.cpp:4:
Lower_Bounded_Counter.h:9:7: error: redefinition of âclass LowerBoundedCounterâ
Lower_Bounded_Counter.h:9:7: error: previous definition of âclass LowerBoundedCounterâ
In file included from Bounded_Counter.h:8:0,
from counterApp.cpp:4:
Upper_Bounded_Counter.h:9:7: error: redefinition of âclass UpperBoundedCounterâ
Upper_Bounded_Counter.h:9:7: error: previous definition of âclass UpperBoundedCounterâ
I am aware that I am including some classes twice, but I don't know how to find it. Can you please help me find what I am doing wrong? There are 4 classes Counter.h, LowerBoundedCounter.h, UpperBoundedCounter.h, and BoundedCounter.h. LowerBoundedCounter.h and UpperBoundedCounter.h both include the Counter.h file. BoundedCounter.h includes both the LowerBoundedCounter.h and the UpperBoundedCounter.h files. The implementation file is counterApp.cpp (not provided here)
Here is the Counter.h class.
#ifndef COUNTER_H
#define COUNTER_H
#include <iostream>
class Counter{
private:
int val;
public:
Counter():val(0) {}
Counter(int val):val(val){}
void up(){
this->val++;
}
void down(){
this->val--;
}
int getVal() const {
return this->val;
}
friend std::ostream &operator <<(std::ostream &os, const Counter &counter) {
os << "A Counter with a value of " << counter.val;
return os;
}
};
#endif
Here is LowerBoundedCounter.h class. This class contains a 'Counter' object.
#ifndef LOWER_BOUNDED_COUNTER_H
#define LOWER_BOUNDER_COUNTER_H
#include<iostream>
#include "Counter.h"
class LowerBoundedCounter{
private:
Counter counter;
int limit;
public:
LowerBoundedCounter(int limit,int val):counter(val), limit(limit){
}
LowerBoundedCounter(int val):counter(val),limit(10){
}
LowerBoundedCounter():counter(),limit(0){
}
void up(){
if(getVal() > limit){
counter.up();
}
}
void down(){
counter.down();
}
int getLimit() const{
return this->limit;
}
int getVal() const{
return counter.getVal();
}
friend std::ostream &operator <<(std::ostream &os, const LowerBoundedCounter &LowerBoundedCounter){
os << "An LowerBoundedCounter with a value of " << LowerBoundedCounter.getVal() << " and a limit of "<<LowerBoundedCounter.limit;
return os;
}
};
#endif
Here's the UpperBoundedCounter.h class
#ifndef UPPER_BOUNDED_COUNTER_H
#define UPPER_BOUNDER_COUNTER_H
#include<iostream>
#include "Counter.h"
class UpperBoundedCounter{
private:
Counter counter;
int limit;
public:
UpperBoundedCounter(int limit,int val):counter(val), limit(limit){
}
UpperBoundedCounter(int val):counter(val),limit(10){
}
UpperBoundedCounter():counter(),limit(10){
}
void up(){
if(getVal() < limit){
counter.up();
}
}
void down(){
counter.down();
}
int getLimit() const {
return this->limit;
}
int getVal() const{
return counter.getVal();
}
friend std::ostream &operator <<(std::ostream &os, const UpperBoundedCounter &UpperBoundedCounter){
os << "An UpperBoundedCounter with a value of " << UpperBoundedCounter.getVal() << " and a limit of "<<UpperBoundedCounter.limit;
return os;
}
};
Finally, I have objects from all 3 of the above classes in BoundedCounter.h
#ifndef BOUNDED_COUNTER_H
#define BOUNDER_COUNTER_H
#include<iostream>
#include "Counter.h"
#include "Lower_Bounded_Counter.h"
#include "Upper_Bounded_Counter.h"
class BoundedCounter{
private:
Counter counter;
UpperBoundedCounter upperBoundedCounter;
LowerBoundedCounter lowerBoundedCounter;
public:
BoundedCounter(int val, int upperLimit, int lowerLimit):counter(val),upperBoundedCounter(upperLimit),lowerBoundedCounter(lowerLimit){
}
BoundedCounter(int val,int upperLimit):counter(val), upperBoundedCounter(upperLimit), lowerBoundedCounter(){
}
BoundedCounter(int val):counter(val),upperBoundedCounter(),lowerBoundedCounter(){
}
BoundedCounter():counter(), upperBoundedCounter(), lowerBoundedCounter(){
}
void up(){
if(getVal() < upperBoundedCounter.getLimit() && getVal() > lowerBoundedCounter.getLimit()){
counter.up();
}
}
void down(){
counter.down();
}
int getLowerLimit() const{
return lowerBoundedCounter.getLimit();
}
int getUpperLimit() const{
return upperBoundedCounter.getLimit();
}
int getVal() const{
return counter.getVal();
}
friend std::ostream &operator <<(std::ostream &os, const BoundedCounter &BoundedCounter){
os << "An BoundedCounter with a value of " << BoundedCounter.getVal() << " and a lower limit of "<<BoundedCounter.getLowerLimit()
<<" and a higher limit of "<<BoundedCounter.getUpperLimit();
return os;
}
};
#endif

Answer 1

Your header protection macro is wrong in all header files.
#ifndef BOUNDED_COUNTER_H
#define BOUNDER_COUNTER_H
Typo 'R'
There is a smaller problem in the UpperBoundedCounter.h, which does not have the closing #endif . But this will cause another problem.