Как настроить цикл, который перебирает возможные элементы таблицы вектора

Question

Программа связана с арифметической последовательностью.Моя программа упорядочена с этими константами, которые используются для индексации

• F = (Первый член в арифметической серии),
• I = (приращение / общая разница между терминами),
• L = (последний член в арифметической серии),
• N = (количество терминов в серии),
• и T = (общее количество путем добавления всех терминов в серии),

Пользователь должен ввести 3 из пяти упомянутых выше 5 символов, а затем двойное значение, которое имеет смысл для каждого символа.

Например:
Если пользователь вводит:

t 3.6 f 1.1 l 1.3

или

T 3.6 F 1.1 L 1.3

Пользователь должен получить вывод

I 0.1 N 3

Это потому, что пользователь дал 3 из 5 опций, определенных как константы

Я определил функции для ответа на все случаи, требуемые при вводе пользователем.Я пометил каждое имя функции первыми 3 буквами, которые являются заданными, а последние две буквы - неизвестными.Для приведенного выше примера вызов void fltin(vector<double> & v, vector<bool> & k) приведет к выводу I и N.(2 случая были освобождены, и я создал функцию, чтобы сообщить пользователю, если эти случаи возникнут ниже)

Другой пример: вызов filnt(vector<double> & v, vector<bool> & k) говорит, что пользователь задает значения F, I и L.Выходные данные должны быть N и T.

Моя проблема: у меня возникли проблемы на последних шагах, где, учитывая ввод данных пользователем (без учета регистра), я могу вызвать правильный элемент вектора в TABLE.Я хочу использовать вектор типа booleans, чтобы также контролировать это.

Вся помощь приветствуется.

#include <iostream>
#include <vector>
#include <cmath>
#include <cstdlib>
#include <string>
using namespace std;
const unsigned F = 0, I = 1, L = 2, N = 3, T = 4;
bool die(const string & msg);
void filnt(vector<double> & v, vector<bool> & k) {
    v[T] = v[F];
    for (double i = (v[F] + v[I]); i <= (v[L] + v[I]); i += v[I]) {
        v[T] += i;
    }
    cout << "T:" << v[T] << " ";
    v[N] = (2 * v[T]) / (v[F] + v[L]);
    cout << "N:" << v[N] << endl;
}
void finlt(vector<double> & v, vector<bool> & k) {
    v[L] = v[F];
    for (double i = 1; i < v[N]; i++) {
        v[L] += v[I];
    }
    cout << "L:" << v[L] << " ";

    v[T] = v[F];
    for (double i = (v[F] + v[I]); i <= (v[L]); i += v[I]) {
        v[T] += i;
    }
    cout << "T:" << v[T] << endl;
}

void fitln(vector<double> & v, vector<bool> & k) {
    bool die("not checking this condition");
}

void flnit(vector<double> & v, vector<bool> & k) {
    v[I] = (v[L] - v[F]) / (v[N] - 1);
    cout << "I:" << v[I] << " ";
    v[T] = v[F];
    for (double i = (v[F] + v[I]); i <= (v[L] + v[I]); i += v[I]) {
        v[T] += i;
    }
    cout << "T:" << v[T] << endl;
}

void fltin(vector<double> & v, vector<bool> & k) {
    v[N] = (2 * v[T]) / (v[F] + v[L]);
    cout << "N:" << v[N] << " ";
    v[I] = (v[L] - v[F]) / (v[N] - 1);
    cout << "I:" << v[I] << endl;
}

void ftnil(vector<double> & v, vector<bool> & k) {
    v[L] = ((2 * v[T]) / v[N]) - v[F];
    cout << "L:" << v[L] << " ";
    v[I] = (v[L] - v[F]) / (v[N] - 1);
    cout << "I:" << v[I] << endl;
}

void iltfn(vector<double> & v, vector<bool> & k) {
    bool die("not checking this condition");
}
void ilnft(vector<double> & v, vector<bool> & k) {
    v[F] = v[L];
    for (double i = 1; i < v[N]; i++) {
        v[F] -= v[I];
    }
    cout << "F:" << v[F] << " ";
    v[T] = v[F];
    for (double i = (v[F] + v[I]); i <= (v[L]); i += v[I]) {
        v[T] += i;
    }
    cout << "T:" << v[T] << endl;
}

void itnfl(vector<double> & v, vector<bool> & k) {
    v[F] = ((v[T] * (2 / v[N])) - ((v[N] - 1)*v[I])) / 2;
    cout << "F:" << v[F] << " ";
    v[L] = ((2 * v[T]) / v[N]) - v[F];
    cout << "L:" << v[L] << endl;
}

void lntfi(vector<double> & v, vector<bool> & k) {
    v[F] = ((2 * v[T]) / v[N]) - v[L];
    cout << "F:" << v[F] << " ";
    v[I] = (v[L] - v[F]) / (v[N] - 1);
    cout << "I:" << v[I] << endl;
}

struct FD { 
    double k1; 
    double k2; 
    double k3;
    double uk1;
    double uk2;
    void(*f)(vector<double> &, vector<bool> &); 
};

const vector<FD> TABLE = {
{F,I,L,N,T,filnt},
{F,I,N,L,T,finlt},
{F,L,N,I,T,flnit},
{F,L,T,I,N,fltin},
{F,T,N,I,L,ftnil},
{I,L,N,F,T,ilnft},
{I,T,N,F,L,itnfl},
{L,N,T,F,I,lntfi}
};


int main() {
    vector<double> v(5);
    vector<bool> k = { false, false, false, false, false };
    char cone;
    char ctwo;
    char cthree;
    double one;
    double two;
    double three;
    cin >> cone;
    cin >> one;
    cin >> ctwo;
    cin >> two;
    cin >> cthree;
    cin >> three;
    // for loop I am having trouble constructing 
    /*

    */
}
bool die(const string & msg) {
    cout << "Fatal Error:" << msg << endl;
    exit(EXIT_FAILURE);
}

Answer 1

Вы можете создать карту

void assign(std::vector<double>& v, std::vector<bool>& flags, char c, double value)
{
    switch (c)
    {
        case 'F': case 'f': v[F] = value; flags[F] = true; break;
        case 'I': case 'i': v[I] = value; flags[I] = true; break;
        case 'L': case 'l': v[L] = value; flags[L] = true; break;
        case 'N': case 'n': v[N] = value; flags[N] = true; break;
        case 'T': case 't': v[T] = value; flags[T] = true; break;
    }
}

int main()
{
    vector<double> v(5);
    vector<bool> flags = { false, false, false, false, false };
    for (int i = 0; i != 3; ++i) {
        char c;
        double value;
        std::cin >> c >> value;
        assign(v, flags, c, value);
    }
    const std::map<std::vector<bool>, void(*)(std::vector<double> &)> m = {
        {{true, true, true, false, false}, filnt},
        {{true, true, false, true, false}, finlt},
        {{true, false, true, true, false}, flnit},
        {{true, false, true, false, true}, fltin},
        {{true, false, false, true, true}, ftnil},
        {{false, true, true, true, false}, ilnft},
        {{false, true, false, true, true}, itnfl},
        {{false, false, true, true, true}, lntfi}
    };
    auto it = m.find(flags);
    if (it == m.end()) {
        std::cout << "Fatal Error: not checking this condition\n";
        return EXIT_FAILURE;
    }
    it->second(v);
}

Демо

Answer 2

Итак, подведем итог, ваша проблема в том, что вы хотите вызвать функцию, основанную на трех символах, введенных пользователем.

Не существует сверхумного способа сделать это.В частности, вы не можете каким-то образом использовать выбранные вами имена функций в логике того, какую функцию вызывать.Поэтому вы должны отбросить имена закодированных функций и выбрать имена, которые на самом деле описывают, что функции делают.

Вероятно, лучший способ - это получить карту из трех буквенных кодов для функции (и, возможно, для vector<bool>, Я не совсем понял этот бит).

#include <string>
#include <vector>
#include <map>

typedef void (*function)(std::vector<double>&, std::vector<bool>&);
std::map<std::string, function> table{{"fil", filnt}, {"fin", finlt}, ... };

Затем вы просто ищете функцию для вызова на основе трехбуквенного кода.

std::string code{cone, ctwo, cthree}; // make three letter code
table[code](v, k); // call appropriate function

Непроверенный код, также выследует добавить проверку ошибок для неверного ввода.