Компилятор не видит структуру внутри класса

#pragma once
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <locale>
#include <stdexcept>
class Sequences
{
public:
    struct SetsStructure
    {
        double RecurrenceEquations;
        double *ElementsOfSets;
        int NumberOfElements;
        int NumberOfSet;
    };
    double *SetsStructure;
public:
    int MethodOfDirect;
    int NumberOfSets;
    int NumberOfElements;
    int EditedSet;
    int RecurrenceRelation;
public:
    static __declspec(dllexport) bool RecursiveAdditionOfSet(int, double)
    {
        std::cin.ignore(10,'\n');
        std::cout << "1. Ввод количества элементов множества с номером" << SetsScructure.NumberOfSet-1 << std::endl;
        std::cin >> NumberOfElements;
        fflush(stdin);
        SetsStructure = new int Sequences.NumberOfElements-1;
        std::cout << "2.Ввод первого члена последовательности (x(0))" << std::endl;
        std::cin >> SetsStructure.ElementsOfSets[0];
        fflush(stdin);
        std::cout << "3.Ввод способа выражения для последующих членов последовательности" << std::endl;
        std::cin >> RecurrenceRelation;
        return 0;
    }
public:
    static __declspec(dllexport) bool InputSets(void)
    {
        int Size;
        std::cin.ignore(10,'\n');
        std::cout << "1.Ввод способа добавления данных" << std::endl;
        std::cin >> MethodOfDirect;
        fflush(stdin);
        std::cout << "2.Ввод количество задаваемых множеств" << std::endl;
        std::cin >> NumberOfSets;
        SetsStructure = new int NumberOfSets;
        for (int i = 0; i < NumberOfSets-1; i++)
        {
            SetsStructure[i].RecurrenceEquations = new double NumberOfSets;
            SetsStructure[i].ElementsOfSets = new double NumberOfSets;
        }
        fflush(stdin);
        std::cout << "3.Ввод номера редактируемого множества" << std::endl;
        std::cin >> EditedSet;
        std::cout << "4.Выберите способ задания множеств" << std::endl;
        return 0;
    }
};

double *SetsStructure; // это как?
SetsScructure.NumberOfSet-1 // тут опечатка в названии

#pragma once
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <locale>
#include <stdexcept>
class Sequences
{
public:
    struct SetsStructure
    {
        static double RecurrenceEquations;
        static double *ElementsOfSets;
        static int NumberOfElements;
        static int NumberOfSet;
    };
    static int MethodOfDirect;
    static int NumberOfSets;
    static int NumberOfElements;
    static int EditedSet;
    static int RecurrenceRelation;
    static int count;
    static __declspec(dllexport) bool RecursiveAdditionOfSet(int NumberOfElements_, int count_, int RecurrenceRelation_, double _SetsStructure)
    {
        std::cin.ignore(10,'\n');
        std::cout << "1. Ввод количества элементов множества с номером" << SetsStructure.NumberOfSet-1 << std::endl;
        std::cin >> Sequences.NumberOfElements;
        fflush(stdin);
        Sequences.SetsStructure = new int Sequences.NumberOfElements-1;
        for (count = 0; count < NumberOfSets-1; count++)
        {
            Sequences.SetsStructure.RecurrenceEquations = new double Sequences.NumberOfSets-1;
            Sequences.SetsStructure.ElementsOfSets = new double Sequences.NumberOfSets-1;
        }
        std::cout << "2.Ввод первого члена последовательности (x(0))" << std::endl;
        std::cin >> SetsStructure.ElementsOfSets[0];
        fflush(stdin);
        std::cout << "3.Ввод способа выражения для последующих членов последовательности" << std::endl;
        std::cin >> RecurrenceRelation;
        return 0;
    }
    static __declspec(dllexport) bool InputSets(void)
    {
        static int Size;
        std::cin.ignore(10,'\n');
        std::cout << "1.Ввод способа добавления данных" << std::endl;
        std::cin >> MethodOfDirect;
        fflush(stdin);
        std::cout << "2.Ввод количество задаваемых множеств" << std::endl;
        std::cin >> NumberOfSets;
        fflush(stdin);
        std::cout << "3.Ввод номера редактируемого множества" << std::endl;
        std::cin >> EditedSet;
        std::cout << "4.Выберите способ задания множеств" << std::endl;
        return 0;
    }
};

std::cout << "1. Ввод количества элементов множества с номером" << SetsStructure::NumberOfSet-1 << std::endl;

Sequences.SetsStructure = new int Sequences.NumberOfElements-1;

// h file
struct SomeStruct
{
   int x;
   int y;
   int z;
};
 
__declspec(dllexport) bool SomeFunction(SomeStruct* someStruct, int arg1, int arg2);
 
 
// cpp file
__declspec(dllexport) bool SomeFunction(SomeStruct* someStruct, int arg1, int arg2)
{
  // тут что-то делаем.
   return true;
}

//Sequences.cpp
#include "stdafx.h"
#include "Sequences.h"
__declspec(dllexport) bool InputSets(Sequences::SetsStructure* setsStructure)
{
    int Size;
    std::cin.ignore(10,'\n');
    std::cout << "1.Ввод способа добавления данных" << std::endl;
    std::cin >> Sequences::SetsStructure::MethodOfDirect;
    fflush(stdin);
    std::cout << "2.Ввод количество задаваемых множеств" << std::endl;
    std::cin >> Sequences::SetsStructure::NumberOfSets[0];
    fflush(stdin);
    std::cout << "3.Ввод номера редактируемого множества" << std::endl;
    std::cin >> Sequences::SetsStructure::EditedSet;
    std::cout << "4.Выберите способ задания множеств" << std::endl;
    return true;
}
__declspec(dllexport) bool RecursiveAdditionOfSet(Sequences::SetsStructure* setsStructure)
{
    std::cin.ignore(10,'\n');
    std::cout << "1. Ввод количества элементов множества с номером" << Sequences::SetsStructure::NumberOfSet-1 << std::endl;
    std::cin >> Sequences::SetsStructure::NumberOfElements;
    fflush(stdin);
    Sequences::SetsStructure::NumberOfSets = new int Sequences::SetsStructure::NumberOfElements-1;
    for (Sequences::SetsStructure::count = 0; &Sequences::SetsStructure::count < Sequences::SetsStructure::NumberOfSets-1; Sequences::SetsStructure::count++)
    {
        Sequences::SetsStructure::RecurrenceEquations[Sequences::SetsStructure::count] = new double Sequences::SetsStructure::NumberOfSets-1;
        Sequences::SetsStructure::ElementsOfSets[Sequences::SetsStructure::count] = new double Sequences::SetsStructure::NumberOfSets-1;
    }
    std::cout << "2.Ввод первого члена последовательности (x(0))" << std::endl;
    std::cin >> Sequences::SetsStructure::ElementsOfSets[0][0];
    fflush(stdin);
    std::cout << "3.Ввод способа выражения для последующих членов последовательности" << std::endl;
    std::cin >> Sequences::SetsStructure::RecurrenceRelation;
    return true;
}
 
//Sequences.h
#pragma once
#include "iostream"
#include "locale.h"
class Sequences
{
public:
    struct SetsStructure
    {
        static double **RecurrenceEquations;
        static double **ElementsOfSets;
        static int *NumberOfSets;
        static int NumberOfElements;
        static int NumberOfSet;
        static int MethodOfDirect;
        static int EditedSet;
        static int RecurrenceRelation;
        static int count;
    };
    __declspec(dllexport) bool InputSets(SetsStructure* setsStructure);
    __declspec(dllexport) bool RecursiveAdditionOfSet(SetsStructure* setsStructure);
};

//recource.h

//Sequences.h
#pragma once
#include "iostream"
#include "locale.h"
class Sequences
{
public:
    struct SetsStructure
    {
        static double **RecurrenceEquations;
        static double **ElementsOfSets;
        static int *NumberOfSets;
        static int NumberOfElements;
        static int NumberOfSet;
        static int MethodOfDirect;
        static int EditedSet;
        static int RecurrenceRelation;
        static int count;
    };
    __declspec(dllexport) bool InputSets(SetsStructure* setsStructure);
    __declspec(dllexport) bool RecursiveAdditionOfSet(SetsStructure* setsStructure);
};

// stdafx.h
#pragma once

//AssemblyInfo.cpp
#include "stdafx.h"
 
using namespace System;
using namespace System::Reflection;
using namespace System::Runtime::CompilerServices;
using namespace System::Runtime::InteropServices;
using namespace System::Security::Permissions;
 
[assembly:AssemblyTitleAttribute("Sequences")];
[assembly:AssemblyDescriptionAttribute("")];
[assembly:AssemblyConfigurationAttribute("")];
[assembly:AssemblyCompanyAttribute("DreamLair")];
[assembly:AssemblyProductAttribute("Sequences")];
[assembly:AssemblyCopyrightAttribute("Copyright (c) DreamLair 2012")];
[assembly:AssemblyTrademarkAttribute("")];
[assembly:AssemblyCultureAttribute("")];
 
[assembly:AssemblyVersionAttribute("1.0.*")];
 
[assembly:ComVisible(false)];
 
[assembly:CLSCompliantAttribute(true)];
 
[assembly:SecurityPermission(SecurityAction::RequestMinimum, UnmanagedCode = true)];

//Sequences.cpp
// Главный DLL-файл.
#include <stdafx.h>
#include "Sequences.h"
__declspec(dllexport) bool InputSets(Sequences::SetsStructure* setsStructure)
{
    int Size;
    std::cin.ignore(10,'\n');
    std::cout << "1.Ввод способа добавления данных" << std::endl;
    std::cin >> Sequences::SetsStructure::MethodOfDirect;
    fflush(stdin);
    std::cout << "2.Ввод количество задаваемых множеств" << std::endl;
    std::cin >> Sequences::SetsStructure::NumberOfSets[0];
    fflush(stdin);
    std::cout << "3.Ввод номера редактируемого множества" << std::endl;
    std::cin >> Sequences::SetsStructure::EditedSet;
    std::cout << "4.Выберите способ задания множеств" << std::endl;
    return true;
}
__declspec(dllexport) bool RecursiveAdditionOfSet(Sequences::SetsStructure* setsStructure)
{
    std::cin.ignore(10,'\n');
    std::cout << "1. Ввод количества элементов множества с номером" << Sequences::SetsStructure::NumberOfSet-1 << std::endl;
    std::cin >> Sequences::SetsStructure::NumberOfElements;
    fflush(stdin);
    Sequences::SetsStructure::NumberOfSets = new int Sequences::SetsStructure::NumberOfElements-1;
    for (Sequences::SetsStructure::count = 0; &Sequences::SetsStructure::count < Sequences::SetsStructure::NumberOfSets-1; Sequences::SetsStructure::count++)
    {
        Sequences::SetsStructure::RecurrenceEquations[Sequences::SetsStructure::count] = new double Sequences::SetsStructure::NumberOfSets-1;
        Sequences::SetsStructure::ElementsOfSets[Sequences::SetsStructure::count] = new double Sequences::SetsStructure::NumberOfSets-1;
    }
    std::cout << "2.Ввод первого члена последовательности (x(0))" << std::endl;
    std::cin >> Sequences::SetsStructure::ElementsOfSets[0][0];
    fflush(stdin);
    std::cout << "3.Ввод способа выражения для последующих членов последовательности" << std::endl;
    std::cin >> Sequences::SetsStructure::RecurrenceRelation;
    return true;
}

//stdafx.cpp
#include "stdafx.h"

//
// main.cpp
//
 
#include <iostream>
#include "main.h"
 
extern "C" __declspec( dllexport ) bool InputSets( test *p )
{
    std::cin >> p->a;
    return true;
}
 
extern "C" __declspec( dllexport ) bool RecursiveAdditionOfSet( test *p )
{
    p->a = 20;
    std::cout << p->a;
    return true;
}

//
// main.h
//
 
class test {
public:
    int a;
};

typedef struct {
    double RecurrenceEquations;
    double *ElementsOfSets;
    int NumberOfElements;
    int NumberOfSet;
} sets_t;
 
int main()
{
    ...
    sets_t    sets[100];    // <--- массив структур. 100 штук
    ...
    return 0;
}

#include <stdio.h>
 
typedef struct {
    double RecurrenceEquations;
    double *ElementsOfSets;
    int NumberOfElements;
    int NumberOfSet;
} sets_t;
 
class Sequences {
protected:
    sets_t *    sets;
 
public:
    bool RecursiveAdditionOfSet( int, double );
};
 
bool Sequences::RecursiveAdditionOfSet( int n, double e )
{
    sets->NumberOfSet = n;
    return true;
}
 
int main()
{
    Sequences   seq;
    seq.RecursiveAdditionOfSet( 1, 2. );
    return 0;
}