wartość zmiennej jako operacja do wykonania

Witam,

mam pytanie odnośnie tego czy jest możliwe użycie wartości zmiennej jako polecenie do programu głównego np.
string m="cin>>n";
chodzi o to, żaby za pomocą zmiennej m użytkownik miał możliwość podania wartości n

Moje pytanie zrodziło się kiedy chciałem stworzyć program, w którym podaje się ciąg poleceń i są one wykonywane dopiero po podaniu ostatniego polecenia w ciągu. Dodatkowo chciałem też dać możliwość podania poleceń w osobnym pliku txt, ale jeżeli da się to zrobić ze zmienną to i z osobnym plikiem nie będzie problemu ;)

Z góry dziękuję za pomoc

Prawie na pewno się da, ale ciężko zrozumieć z Twojego posta co konkretnie chcesz osiągnąć

może podam przykład, żeby było łatwiej zrozumieć co mam na myśli:
W programie dany jest losowy ciąg liczb. W moim pliku txt mam podene nazwy funkcji takie jak min, max, add, delete.
przykład zawartości pliku txt
max
add 99
max
min
Teraz chciałbym, aby program był w stanie wykonać te funkcje, jednak moje umiejętności kończą się na pobraniu zawartości pliku, a nie wykonaniu tej zawartości

Jak najbardziej, ale dla newbie to może nie być trywialne. Zacznij od zdefiniowania gramatyki (nie musi być formalnie, ale add przyjmuje u Ciebie argument, a inne rozkazy nie) i podzielenia wejścia na konkretne rozkazy. Potem możesz zająć się przypisywaniem ich do funkcji

Niestety nie jest to dla mnie trywialny problem.

1. Prawdę mówiąc dalej nie do końca wiem jak to ma działać, myślałem że będę pobierać całe wiersze z pliku txt i dalej nie wiedziałem co.
2. Gramatyka będzie tutaj przydatna tylko do sprawdzenia czy składnia polecenia jest poprawna czy ma to jakiś większe znaczenie?
3. Podzielenie wejścia na konkretne rozkazy, czyli z jednego wiersza jeden rozkaz?(rozkazem będzie np. "add 5"?)
4. I chyba moje najważniejsze pytanie: jak przypisać do "rozkazu" funkcję która ma się wykonać?

Nie wiem, czy na pewno dobrze zrozumiałem o co Ci chodzi:

 

void DoSomething(int c)
{
     printf("%d\n" , c);
}

int main()
{
    void (*SomeFunction)(int c) = DoSomething;

    SomeFunction(10);
}

Aczkolwiek nie jest to zbyt eleganckie i to jest w C. Samego C++ dobrze nie znam i tam pewnie jest jakis lepszy sposob

 

void max()
{
  int max=tab[0];
  for( int i = 1; i <= 9; i++ ){
    if (tab[i]>max) max=tab[i];
  }
 printf("%d\n" ,max);
}
 
int main()
{
 for( int i = 0; i <= 9; i++ ){
    tab[i]=rand() % 100;
  }
}

plik operacje.txt
max

i teraz chodzi mi, żeby zawartość pliku txt wywoływała odpowiednie funkcje w tym przypadku max. Umiem jedynie wypisać zawartość pliku txt.
Jedyny sposób jaki znam to wywołać max w części main(), a mi zależy żeby na podstawie zawartości pliku txt wykonać odpowiednie funkcję

w petli robisz tak

pobierasz linie (najlepiej do tego uzyc std::vector)
zapisujesz sobie pierwsze slowo (w sensie pobierasz z std::vector pierwszy element)
robisz switcha na podstawie tego slowa (uzyj std::map bo switch na stringu nie jest fajny... da sie ale nie jest fajny)
w switchu jezeli funkcja potrzebuje argumentow to pobierasz argumenty z tej linii co pobirales (kolejne elementy std::vectora)
wywolujesz funkcje jaka chcesz

az do konca pliku

Taki przykład przyszedł mi do głowy:

#include <iostream>
#include <string>
#include <map>

int add(int a, int b)
{
	return a + b;
}

int subt(int a, int b)
{
	return a - b;
}

int main()
{
	typedef int(*funPtr)(int, int);

	std::map<std::string, funPtr> arrFunPtr;
	arrFunPtr["add"] = &add;
	arrFunPtr["subt"] = &subt;

	int a, b;
	std::string op;

	if (std::cin >> a >> b && file >> op)  // wykonaj jeśli udało się pobrać wszystkie dane
	{
		auto posKey = arrFunPtr.find(op);  // wyszukaj z tablicy asocjacyjnej klucz o wartości pobranej z pliku
		if (posKey != arrFunPtr.end()) // jeśli znaleziono wykonaj funkcję
		{
			std::cout << posKey->second(a, b) << std::endl;
		}
		else
		{
			std::cerr << "Nie ma takiej operacji" << std::endl;
		}
	}
	else
		std::cerr << "Blad wczytywania danych" << std::endl;
} 

Możesz zawsze użyć funkcji, które oferuje ci C++11 i napisać to w tym stylu (to tylko wolna koncepcja, wymagająca poprawek)

#include <functional>
#include <iostream>
#include <iterator>
#include <map>
#include <sstream>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>


namespace {

struct argument
{
	std::string value;

	operator bool() const { return value == "true"; }
	operator float() const { return std::stof(value); }
	operator int() const { return std::stoi(value); }
	operator std::string() const { return value; }
};

template<typename Result, typename... Args, std::size_t... I>
Result call_impl(Result (*function)(Args...), std::vector<std::string> arguments,
               std::index_sequence<I...>)
{
	return function(argument{arguments[I]}...);
}

}

template<typename Result, typename... Args>
Result call(Result (*function)(Args...), std::vector<std::string> arguments)
{
	return call_impl(function, arguments, std::make_index_sequence<sizeof...(Args)>{});
}

template<typename Result, typename... Args>
std::function<void(std::vector<std::string>)> functor(Result (*function)(Args...))
{
	return [function](std::vector<std::string> arguments) {
		std::cout << call(function, arguments) << std::endl;
	};
}

std::vector<std::string> split(const std::string& str, char delim)
{
	std::vector<std::string> elements;
	std::stringstream stream(str);

	std::string element;
	while (std::getline(stream, element, delim)) {
		elements.push_back(element);
	}

	return elements;
}

int plus(int x, int y)
{
	return x + y;
}

int negate(int x)
{
	return -x;
}

int main()
{
	using functor_type = std::function<void(std::vector<std::string>)>;

	std::map<std::string, functor_type> functions;
	functions["add"] = functor(plus);
	functions["negate"] = functor(negate);

	std::string input;
	while (std::getline(std::cin, input)) {
		if (input == "quit") {
			break;
		}

		std::vector<std::string> parameters = split(input, ' ');

		auto func = functions[parameters[0]];

		parameters.erase(parameters.begin());
		func(parameters);
	}

	return 0;
}