Множественное определение переменной

#ifndef UICOMPONENTS_H
#define UICOMPONENTS_H
 
#include <QtGui>
 
#include <QPlainTextEdit>
#include <QPushButton>
#include <QHBoxLayout>
#include <QVBoxLayout>
 
#include "Logic.h"
 
class UIComponents : public QWidget
{
    Q_OBJECT
public:
    explicit UIComponents(QWidget *pwgt = 0);
 
 
    QVBoxLayout*    GetLayout();
 
public slots:
    void    InputTextChangedHandler();
 
    void    btnVerifyHandler();
    void    btnCalculateHandler();
    void    btnClearHandler();
 
private:
    QPlainTextEdit* mInputEdit;
    QPlainTextEdit* mOutputEdit;
 
    QPushButton*    mbtnVerify;
    QPushButton*    mbtnCalculate;
    QPushButton*    mbtnClear;
 
    QVBoxLayout*    mLayout;
 
    CLogic          mLogicImpl;
};
 
#endif // UICOMPONENTS_H

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
 
#include <QMainWindow>
 
#include "UIComponents.h"
 
class MainWindow : public QMainWindow
{
    Q_OBJECT
 
public:
    MainWindow(QWidget *parent = 0);
    ~MainWindow();
 
private:
    int             mWidth;
    int             mHeight;
 
    UIComponents    mUIComponents;
};
 
#endif // MAINWINDOW_H

#include "mainwindow.h"
#include <QApplication>
 
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
 
    return a.exec();
}

#include "Logic.h"
 
#include <QtAlgorithms>
#include <algorithm>
 
 
CLogic::CLogic() :
    mMaxCountriesCount(20),
    mMinCountriesCount(1),
    mCountriesCount(-1),
    mFinishFlag(0)
{
    mCountriesCountReg  = QRegExp("^\\d\\d?$");
    mCountryNameReg     = QRegExp("[A-Za-z]{1,25}");
    mCityCoordReg       = QRegExp("^\\d\\d?$");
}
 
bool CLogic::Verification(QString input) {
    mSplittedString.clear();
 
    mSplittedString = input.split(QRegExp("\\s+"));
 
    auto iter = mSplittedString.constBegin();
 
    VERIFICATION_CODE result;
 
    while(true) {
        result = CheckCountriesCount(iter);
 
        if(result != VALID_COUNTRIES_COUNT) {
 
            if(result == FINISH_VERIFICATION) {
                ShowMessage(result);
                return true;
            }
 
            ShowMessage(result);
            return false;
        }
 
 
        result = CheckCountriesData(iter);
 
        if(result != VALID_COUNTRIES_DATA) {
            ShowMessage(result);
            return false;
        }
    }
}
 
bool CLogic::IsValidIterator(QStringList::const_iterator &iter) {
    if(iter == mSplittedString.end()) {
        return false;
    }
 
 
    return true;
}
 
VERIFICATION_CODE CLogic::CheckCountriesCount(QStringList::const_iterator& iter) {
    if(!IsValidIterator(iter)) {
        return INVALID_END_OF_TEXT;
    }
 
    // returns true if string is matched exactly
    if(mCountriesCountReg.exactMatch(*iter)) {
        mCountriesCount = (*iter).toInt();
 
        // if iter reference to 0
        if(mCountriesCount == mFinishFlag) {
            return FINISH_VERIFICATION;
        }
 
        if(mCountriesCount < mMinCountriesCount ||
           mCountriesCount > mMaxCountriesCount) {
 
            return COUNTRIES_NUMBER_OUT_OF_RANGE;
        }
 
        CCase newCase;
        mCurrentCase = newCase;
 
        ++iter;
 
        return VALID_COUNTRIES_COUNT;
    }
 
    return UNACCEPTABLE_COUNTRIES_COUNT;
}
 
VERIFICATION_CODE CLogic::CheckCountriesData(QStringList::const_iterator &iter) {
 
    for(int i = 0;i < mCountriesCount;++i) {
        if(!IsValidIterator(iter)) {
            return INVALID_END_OF_TEXT;
        }
 
        if(!( mCountryNameReg.exactMatch(*iter) )) {
            // check appear of new case
            if(mCountriesCountReg.exactMatch(*iter)) {
                // don't expected countries data
                if(mCountriesCount == -1) {
                    mCases.push_back(mCurrentCase);
                    return NEW_CASE;
                }
            }
 
            return INVALID_COUNTRY_NAME;
        }
 
        mCountryName = *iter;
 
        ++iter;
 
        int coord = -1;
 
        Coord countryCoord;
 
        for(int j = 0;j < CoordCount;++j) {
            if(!IsValidIterator(iter)) {
                return INVALID_END_OF_TEXT;
            }
 
            if(!(*iter).contains(mCityCoordReg)) {
                return INVALID_CITY_COORD;
            }
 
            coord = (*iter).toInt();
 
            if(j == lbXIndex ||
               j == ruXIndex) {
 
                if(coord < MinXCoordValue ||
                   coord > MaxXCoordValue) {
 
                    return CITY_COORD_OUT_OF_RANGE;
                }
            }
 
            if(j == lbYindex ||
               j == ruYIndex) {
 
                if(coord < MinYCoordValue ||
                   coord > MaxYCoordValue) {
 
                    return CITY_COORD_OUT_OF_RANGE;
                }
            }
 
            countryCoord.coord.push_back(coord);
 
            ++iter;
        }
 
        mCurrentCase.SetCountryData(mCountryName, countryCoord);
    }
 
    mCases.push_back(mCurrentCase);
 
    mCountriesCount = -1;
 
    return VALID_COUNTRIES_DATA;
}

CCase::CCase() :
    mOffsetX(MaxXCoordValue),
    mOffsetY(MaxYCoordValue),
    mArrayWidth(0),
    mArrayHeight(0),
    mComplete(false)
{
}
 
CCase::~CCase() {
    for(int i = 0;i < mArrayWidth;++i) {
        delete mCities[i];
    }
 
    delete mCities;
}
 
void CCase::SetCountryData(QString name, Coord countryCoord) {
    Country country;
 
    country.Name = name;
    country.CountryCoord = countryCoord;
 
    mCountries.push_back(country);
    mCountriesNames.push_back(name);
 
    mOffsetX = qMin(mOffsetX, countryCoord.coord[lbXIndex]);
    mOffsetY = qMin(mOffsetY, countryCoord.coord[lbYindex]);
 
    int newWidth = countryCoord.coord[ruXIndex] - mOffsetX + 1;
    int newHeight = countryCoord.coord[ruYIndex] - mOffsetY + 1;
 
    mArrayWidth = qMax(mArrayWidth, newWidth);
    mArrayHeight = qMax(mArrayHeight, newHeight);
}