Hey, I have just been studying how to implement reflection in the simplest and least expensive way possible in c++.

I've been studying up on macros, since those are all pre-processor, but I can't seem to find a way to accomplish what I am trying to do.

Sorry if this sounds kinda stupid. I am just sorta learning this stuff. I want to write a macro function that takes a string literal (for a variable or function name), and put it in a vector. The only problem is, I don't know how to create a vector in the preprocessing stage.

I was wondering if it is possible to create some sort of 'macro class' or struct to store this data, so that I can use this for later.

For example, I want to do something like this:

Psuedo-code:
#include <iostream>
#include <string>
#include <vector>

#define struct ReflectionData /
{/
    std::vector<string> names;/
}

#define ADD_REFLECTION_DATA(std::string data) (ReflectionData.names.push_back(data))

ADD_REFLECTION_DATA("mario")
ADD_REFLECTION_DATA("luigi")

int main()
{
    std::cout << ReflectionData.names[0];
    std::cout << ReflectionData.names[1];
    std::cout << ReflectionData.names[2];

    return 0;
}

ADD_REFLECTION_DATA("Bowser")

Output:
Mario
Luigi
Bowser

Any idea how to accomplish something like this?

Not sure what you're after but the preprocessor is totally unaware of C++ constructs like structs.
It runs before the compiler even starts munching through your code and acts as a text replacer.

I want the program to store strings inside of a vector during the preprocessor stage, and then output the data after it has been compiled during runtime. I eventually want to also store boost::function_pointers to functions in the classes, and use the data for metaprogramming, so that other classes can call each others functions without circular dependencies, similar to what Unity and UE4 does.

Ok, I still haven't figured out how to do it but I managed to get somewhere closer to the answer, and this article helped: http://www.randygaul.net/2012/10/01/c-reflection-type-metadata-introduction/

here is the code that I wrote:

#include <windows.h>

#include "reflector.h"

int main()
{
	REFL_ADD_NAME("mario");
	std::string reflectName = ReflectionManager::names[0];

	std::cout << '\n' << reflectName;
	return 0;
}

#ifndef REFLECTOR_H_
#define REFLECTOR_H_

#include <iostream>
#include <string>
#include <vector>

class ReflectionManager
{
public:
    static std::vector< std::string > names;

    static const void AddName(std::string name)
    {
        names.push_back(name);
    };
};

std::vector< std::string > ReflectionManager::names;

#define REFL_ADD_NAME(NAME)(ReflectionManager::AddName(NAME))

#endif /* REFLECTOR_H_ */

Unfortunately this doesn't work if I place the REFL_ADD_NAME("mario"); function outside of main, which leads me to believe that the macro function is being called at runtime. Ugh. I wan't the macro to be called only at the preprocessing stage. Any info on how to do this?

You can not run code outside of a function (with the exception of putting it into a constructor for a static variable in C++). Thats basic C/C++ knowledge.

*sigh, I understand you can't run code outside a function, that's why i'm asking for help. Afaik Boost::mpl has a good solution that runs preprocessor code outside of functions and during compile time using template metaprogramming. I might use that instead.