Общая молекулярная масса, Химия C++

@GmosseN · Регистрация: 15.04.2019

Студворк — интернет-сервис помощи студентам

Есть вот такой вот огромный код, смысл его найти общую молекулярную массу, но у меня ничего не получается.Я сделал класс который хранит название, элемент и его массу.При вводе текст разделяется на элементы.При вводе допустим SO должно вывести 48, но оно выводит только массу последнего элемента, а это O(16), как сделать что бы учитывалось и S и еще коэфициенты рядом с цифрой потипу SO4 = 32+16*4?
И если у вас есть еще какие-то подсказки как улучшить код пишите, буду очень благодарен.

C++

#include <iostream>
#include "Chemistry.h"
using namespace std;
 
 
int main()
{
    Chemistry* e[118];
    Chemistry H =  { "Hydrogenium"  , "Водород"      , "H"   , 1, 1,  1, 1 };
    Chemistry He = { "Helium"       , "Гелий"      , "HE"  , 2, 18, 1, 4 };
    Chemistry Li = { "Lithium"      , "Литий"      , "Li"  , 3, 1,  2, 6 };
    Chemistry Be = { "Beryllium"    , "Бериллий"    , "Be"  , 4, 2,  2, 9 };
    Chemistry B =  { "Borum"        , "Бор"          , "B"   , 5, 13, 2, 10 };
    Chemistry C =  { "Carboneum"    , "Углерод"      , "C"   , 6, 14, 2, 12 };
    Chemistry N =  { "Nitrogenium"  , "Азот"        , "N"   , 7, 15, 2, 14 };
    Chemistry O =  { "Oxygenium"    , "Кислород"    , "O"   , 8, 16, 2, 16 };
    Chemistry F =  { "Fluorum"      , "Фтор"        , "F"   , 9, 17, 2, 18 };
    Chemistry Ne = { "Neon"         , "Неон"        , "Ne"  , 10, 18,2, 20 };
    Chemistry Na = { "Natrium"      , "Натрий"        , "Na"  , 11, 1, 3, 22 };
    Chemistry Mg = { "Magnesium"    , "Магний"        , "Mg"  , 12, 2, 3, 24 };
    Chemistry Al = { "Aluminium"    , "Алюминий"    , "Al"  , 13, 13,3, 26 };
    Chemistry Si = { "Silicium"     , "Кремний"      , "Si"  , 14, 14,3, 28 };
    Chemistry P =  { "Phosphorus"   , "Фосфор"        , "P"   , 15, 15,3, 30 };
    Chemistry S =  { "Sulphur"      , "Сера"        , "S"   , 16, 16,3, 32 };
    Chemistry Cl = { "Chlorum"      , "Хлор"        , "Cl"  , 17, 17,3, 35 };
    Chemistry Ar = { "Argon"        , "Аргон"      , "Ar"  , 18, 18,3, 38 };
    Chemistry K =  { "Kalium"       , "Калий"      , "K"   , 19, 1, 4, 39 };
    Chemistry Ca = { "Calcium"      , "Кальций"      , "Ca"  , 20, 2, 4, 40 };
    Chemistry Sc = { "Scandium"     , "Скандий"      , "Sc"  , 21, 3, 4, 44 };
    Chemistry Ti = { "Titanium"     , "Титан"      , "Ti"  , 22, 4, 4, 47 };
    Chemistry V =  { "Vanadium"     , "Ванадий"      , "V"   , 23, 5, 4, 50 };
    Chemistry Cr = { "Chromium"     , "Хром"        , "Cr"  , 24, 6, 4, 52 };
    Chemistry Mn = { "Manganum"     , "Марганец"    , "Mn"  , 25, 7, 4, 55 };
    Chemistry Fe = { "Ferrum"       , "Железо"        , "Fe"  , 26, 8, 4, 56 };
    Chemistry Co = { "Cobaltum"     , "Кобальт"      , "Co"  , 27, 9, 4, 59 };
    Chemistry Ni = { "Niccolum"     , "Никель"        , "Ni"  , 28, 10,4, 58 };
    Chemistry Cu = { "Cuprum"       , "Медь"        , "Cu"  , 29, 11,4, 63 };
    Chemistry Zn = { "Zincum"       , "Цинк"        , "Zn"  , 30, 12,4, 65 };
    Chemistry Ga = { "Gallium"      , "Галлий"        , "Ga"  , 31, 13,4, 69 };
    Chemistry Ge = { "Germanium"    , "Германий"    , "Ge"  , 32, 14,4, 72 };
    Chemistry As = { "Arsenicum"    , "Мышьяк"        , "As"  , 33, 15,4, 74 };
    Chemistry Se = { "Selenium"     , "Селен"      , "Se"  , 34, 16,4, 78 };
    Chemistry Br = { "Bromum"       , "Бром"        , "Br"  , 35, 17,4, 79 };
    Chemistry Kr = { "Krypton"      , "Криптон"      , "Kr"  , 36, 18,4, 83 };
    Chemistry Rb = { "Rubidium"     , "Рубидий"      , "Rb"  , 37, 1, 4, 85 };
    Chemistry Sr = { "Strontium"    , "Стронций"    , "Sr"  , 38, 2, 1, 87 };
    Chemistry Y =  { "Yttrium"      , "Иттрий"        , "Y"   , 39, 3, 5, 88 };
    Chemistry Zr = { "Zirconium"    , "Цирконий"    , "Zr"  , 40, 4, 5, 91 };
    Chemistry Nb = { "Niobium"      , "Ниобий"        , "Nb"  , 41, 4, 5, 92 };
    Chemistry Mo = { "Molybdaenum"  , "Молибден"    , "Mo"  , 42, 5, 5, 95 };
    Chemistry Tc = { "Technetium"   , "Технеций"    , "Tc"  , 43, 7, 5, 98 };
    Chemistry Ru = { "Ruthenium"    , "Рутений"      , "Ru"  , 44, 8, 5, 101 };
    Chemistry Rh = { "Rhodium"      , "Родий"      , "Rh"  , 45, 9, 5, 102 };
    Chemistry Rd = { "Palladium"    , "Палладий"    , "Rd"  , 46, 10,5, 106 };
    Chemistry Ag = { "Argentum"     , "Серебро"      , "Ag"  , 47, 11,5, 107 };
    Chemistry Cd = { "Cadmium"      , "Кадмий"        , "Cd"  , 48, 12,5, 112 };
    Chemistry In = { "Indium"       , "Индий"      , "In"  , 49, 13,5, 114 };
    Chemistry Sn = { "Stannum"      , "Олово"      , "Sn"  , 50, 14,5, 118 };
    Chemistry Sb = { "Stibium"      , "Сурьма"        , "Sb"  , 51, 15,5, 121 };
    Chemistry Te = { "Tellurium"    , "Теллур"        , "Te"  , 52, 16,5, 127 };
    Chemistry I =  { "Iodium"       , "Иод"          , "I"   , 53, 17,5, 126 };
    Chemistry Xe = { "Xenon"        , "Ксенон"        , "Xe"  , 54, 18,5, 131 };
    Chemistry Cs = { "Caesium"      , "Цезий"      , "Cs"  , 55, 1, 6, 132 };
    Chemistry Ba = { "Barium"       , "Барий"      , "Ba"  , 56, 2, 6, 137 };
    Chemistry La = { "Lanthanum"    , "Лантан"        , "La"  , 57, 0, 6, 138 };
    Chemistry Ce = { "Cerium"       , "Церий"      , "Ce"  , 58, 0, 6, 140 };
    Chemistry Pr = { "Praseodymium" , "Празеодим"  ,"Pr"   , 59, 0, 6, 141 };
    Chemistry Nd = { "Neodymium"    , "Неодим"        , "Nd"  , 60, 0, 6, 144 };
    Chemistry Pm = { "Promethium"   , "Прометий"    , "Pm"  , 61, 0, 6, 146 };
    Chemistry Sm = { "Samarium"     , "Самарий"      , "Sm"  , 62, 0, 6, 150 };
    Chemistry Eu = { "Europium"     , "Европий"      , "Eu"  , 63, 0, 6, 151 };
    Chemistry Gd = { "Gadolinium"   , "Гадолиний"  ,"Gb"   , 64, 0, 6, 157 };
    Chemistry Tb = { "Terbium"      , "Тербий"        , "Tb"  , 65, 0, 6, 158 };
    Chemistry Dy = { "Dysprosium"   , "Диспрозий"  ,"Dy"   , 66, 0, 6, 162 };
    Chemistry Ho = { "Holmium"      , "Гольмий"      , "Ho"  , 67, 0, 6, 164 };
    Chemistry Er = { "Erbium"       , "Эрбий"      , "Er"  , 68, 0, 6, 167 };
    Chemistry Tm = { "Thulium"      , "Тулий"      , "Tm"  , 69, 0, 6, 168 };
    Chemistry Yb = { "Ytterbium"    , "Иттербий"    , "Yb"  , 70, 0, 6, 173 };
    Chemistry Lu = { "Lutetium"     , "Лютеций"      , "Lu"  , 71, 3, 6, 174 };
    Chemistry Hf = { "Hafnium"      , "Гафний"        , "Hf"  , 72, 4, 6, 178 };
    Chemistry Ta = { "Tantalum"     , "Тантал"        , "Ta"  , 73, 5, 6, 180 };
    Chemistry W =  { "Wolframium"   , "Вольфрам"    , "W"   , 74, 6, 6, 183 };
    Chemistry Re = { "Rhenium"      , "Рений"      , "Re"  , 75, 7, 6, 186 };
    Chemistry Os = { "Osmium"       , "Осмий"      , "Os"  , 76, 8, 6, 190 };
    Chemistry Ir = { "Iridium"      , "Иридий"        , "Ir"  , 77, 9, 6, 192 };
    Chemistry Pt = { "Platinum"     , "Платина"      , "Pt"  , 78, 10,6, 195 };
    Chemistry Au = { "Aurum"        , "Золото"        , "Au"  , 79, 11,6, 196 };
    Chemistry Hg = { "Hydrargyrum"  , "Ртуть"      , "Hg"  , 80, 12,6, 200 };
    Chemistry TI = { "Thallium"     , "Таллий"        , "Ti"  , 81, 13,6, 204 };
    Chemistry Pb = { "Plumbum"      , "Свинец"        , "Pb"  , 82, 14,6, 207 };
    Chemistry Bu = { "Bismuthum"    , "Висмут"        , "Bu"  , 83, 15,6, 208 };
    Chemistry Po = { "Polonium"     , "Полоний"      , "Po"  , 84, 16,6, 209 };
    Chemistry At = { "Astatum"      , "Астат"      , "At"  , 85, 17,6, 210 };
    Chemistry Rn = { "Radon"        , "Радон"      , "Rn"  , 86, 18,6, 222 };
    Chemistry Fr = { "Francium"     , "Франций"      , "Fr"  , 87, 1, 7, 223 };
    Chemistry Ra = { "Radium"       , "Радий"      , "Ra"  , 88, 2, 7, 226 };
    Chemistry Ac = { "Actinium"     , "Актиний"      , "Ac"  , 89, 0, 7, 227 };
    Chemistry Th = { "Thorium"      , "Торий"      , "Th"  , 90, 0, 7, 232 };
    Chemistry Pa = { "Protactinium" , "Протактиний"  ,"Pa", 91, 0, 7, 231 };
    Chemistry U =  { "Uranium"      , "Уран"        , "U"   , 92, 0, 7, 238 };
    Chemistry Np = { "Neptunium"    , "Нептуний"    , "Np"  , 93, 0, 7, 237 };
    Chemistry Pu = { "Plutonium"    , "Плутоний"    , "Pu"  , 94, 0, 7, 244 };
    Chemistry Am = { "Americium"    , "Америций"    , "Am"  , 95, 0, 7, 243 };
    Chemistry Cm = { "Curium"       , "Кюрий"      , "Cm"  , 96, 0, 7, 247 };
    Chemistry Bk = { "Berkelium"    , "Берклий"      , "Bk"  , 97, 0, 7, 248 };
    Chemistry Cf = { "Californium"  , "Калифорний"    ,"Cf"   , 98, 0, 7, 251 };
    Chemistry Es = { "Einsteinium"  , "Эйнштейний"    ,"Es"   , 99, 0, 7, 252 };
    Chemistry Fm = { "Fermium"      , "Фермий"        , "Fm"  , 100, 0,7, 257 };
    Chemistry Md = { "Mendelevium"  , "Менделевий"    ,"Md"   , 101, 0,7, 258 };
    Chemistry No = { "Nobelium"     , "Нобелий"      , "No"  , 102, 0,7, 259 };
    Chemistry Lr = { "Lawrencium"   , "Лоуренсий"  , "Lr"  , 103, 3,7, 266 };
    Chemistry Rf = { "Rutherfordium","Резерфордий"   ,"Rf", 104, 4,7, 267 };
    Chemistry Db = { "Dubnium"      , "Дубний"        , "Db"  , 105, 5,7, 268 };
    Chemistry Sg = { "Seaborgium"   , "Сиборгий"    , "Sg"  , 106, 6,7, 269 };
    Chemistry Bh = { "Bohrium"      , "Борий"      , "Bh"  , 107, 7,7, 270 };
    Chemistry Hs = { "Hassium"      , "Хассий"        , "Hs"  , 108, 8,7, 277 };
    Chemistry Mt = { "Meitnerium"   , "Мейтнерий"  , "Mt"  , 109, 9,7, 278 };
    Chemistry Ds = { "Darmstadtium" , "Дармштадтий"  ,"Ds", 110, 10,7,281 };
    Chemistry Rg = { "Roentgenium"  , "Рентгений"  , "Rg"  , 111, 11,7, 282 };
    Chemistry Cn = { "Copernicium"  , "Коперниций"    , "Cn", 112, 12,7, 285 };
    Chemistry Nh = { "Nihonium"     , "Нихоний"      , "Nh"  , 113, 13,7, 286 };
    Chemistry Fl = { "Flerovium"    , "Флеровий"    , "Fl"  , 114, 14,7, 289 };
    Chemistry Mc = { "Moscovium"    , "Московий"    , "Mc"  , 115, 15,7, 290 };
    Chemistry Lv = { "Livermorium"  , "Ливерморий"    , "Lv", 116, 16,7, 293 };
    Chemistry Ts = { "Tennessine"   , "Теннессин"  , "Ts"  , 117, 17,7, 294 };
    Chemistry Og = { "Oganesson"    , "Оганесон"    , "Og"  , 118, 18,7, 294 };
    e[0] = &H;
    e[1] = &He;
    e[2] = &Li;
    e[3] = &Be;
    e[4] = &B;
    e[5] = &C;
    e[6] = &N;
    e[7] = &O;
    e[8] = &F;
    e[9] = &Ne;
    e[10] = &Na;
    e[11] = &Mg;
    e[12] = &Al;
    e[13] = &Si;
    e[14] = &P;
    e[15] = &S;
    e[16] = &Cl;
    e[17] = &Ar;
    e[18] = &K;
    e[19] = &Ca;
    e[20] = &Sc;
    e[21] = &Ti;
    e[22] = &V;
    e[23] = &Cr;
    e[24] = &Mn;
    e[25] = &Fe;
    e[26] = &Co;
    e[27] = &Ni;
    e[28] = &Cu;
    e[29] = &Zn;
    e[30] = &Ga;
    e[31] = &Ge;
    e[32] = &As;
    e[33] = &Se;
    e[34] = &Br;
    e[35] = &Kr;
    e[36] = &Rb;
    e[37] = &Sr;
    e[38] = &Y;
    e[39] = &Zr;
    e[40] = &Nb;
    e[41] = &Mo;
    e[42] = &Tc;
    e[43] = &Ru;
    e[44] = &Rh;
    e[45] = &Rd;
    e[46] = &Ag;
    e[47] = &Cd;
    e[48] = &In;
    e[49] = &Sn;
    e[50] = &Sb;
    e[51] = &Te;
    e[52] = &I;
    e[53] = &Xe;
    e[54] = &Cs;
    e[55] = &Ba;
    e[56] = &La;
    e[57] = &Ce;
    e[58] = &Pr;
    e[59] = &Nd;
    e[60] = &Pm;
    e[61] = &Sm;
    e[62] = &Eu;
    e[63] = &Gd;
    e[64] = &Tb;
    e[65] = &Dy;
    e[66] = &Ho;
    e[67] = &Er;
    e[68] = &Tm;
    e[69] = &Yb;
    e[70] = &Lu;
    e[71] = &Hf;
    e[72] = &Ta;
    e[73] = &W;
    e[74] = &Re;
    e[75] = &Os;
    e[76] = &Ir;
    e[77] = &Pt;
    e[78] = &Au;
    e[79] = &Hg;
    e[80] = &TI;
    e[81] = &Pb;
    e[82] = &Bu;
    e[83] = &Po;
    e[84] = &At;
    e[85] = &Rn;
    e[86] = &Fr;
    e[87] = &Ra;
    e[88] = &Ac;
    e[89] = &Th;
    e[90] = &Pa;
    e[91] = &U;
    e[92] = &Np;
    e[93] = &Pu;
    e[94] = &Am;
    e[95] = &Cm;
    e[96] = &Bk;
    e[97] = &Cf;
    e[98] = &Es;
    e[99] = &Fm;
    e[100] = &Md;
    e[101] = &No;
    e[102] = &Lr;
    e[103] = &Rf;
    e[104] = &Db;
    e[105] = &Sg;
    e[106] = &Bh;
    e[107] = &Hs;
    e[108] = &Mt;
    e[109] = &Ds;
    e[110] = &Rg;
    e[111] = &Cn;
    e[112] = &Nh;
    e[113] = &Fl;
    e[114] = &Mc;
    e[115] = &Lv;
    e[116] = &Ts;
    e[117] = &Og;
    int arg=0;
    string ker;
    string formula;
    cin >> formula;
    const char* str = formula.c_str();
    const char* first = str;
    while (*str)
    {
        if (isupper(unsigned(*str)) && first != str)
        {           
            cout.write(first, str - first) << endl;
            ker = first - str;
            first = str;
        }
        for (int i = 0; i < 117; i++)
        {
            if (ker == e[i]->sym)
            {
                arg += e[i]->Ar;
            }
        }
        ++str;
 
    }
 
    cout.write(first, str - first) << endl;
    cout << arg;
 
}

@XLAT · 15.04.2020, 14:50

Сообщение от GmosseN

И если у вас есть еще какие-то подсказки как улучшить код пишите, буду очень благодарен.

много раз наблюдал такую картину, но спрошу впервый раз:
почему сначала автор пишет 100500 строк кода,
а потом не может понять где у него не работает?

Ведь известно, чтобы доказать существование океана, достаточно наличие одной капли воды.

Можно же написать простые компактные куски идиоматного кода,
тщательно их протестировать, а затем уже увеличить масштаб?

Почему нет???

Сообщение от GmosseN

Chemistry* e[118];

даже не вникая в вашу задачу это лишняя сущность.

вот вполне достачно для хранения всех нужных данных

C++

/// Это сокращенный вариант:
/// Это сокращенный вариант:
#include <iostream>
#include <string>
#include <iomanip>
 
struct Chemistry
{   std::string   name;
    std::string  rname;
    std::string idname;
    int m[4];
    
    void info()
    {   std::cout << std::setw(12) << name   << "  " 
                  << std::setw(10) << rname  << "  " 
                  << std::setw(5)  << idname << "  ";
        for(int j = 0; j < 4; j++)
        {   std::cout << m[j] << "\t";
        }   std::cout              << "\n";
    }
}   
 
E[]  = 
{ 
    { "Hydrogenium"  , "Водород"  , "H"   , 1,  1,  1, 1 },
    { "Helium"       , "Гелий"    , "HE"  , 2, 18,  1, 4 },
    { "Lithium"      , "Литий"    , "Li"  , 3,  1,  2, 6 },
    { "Beryllium"    , "Бериллий" , "Be"  , 4,  2,  2, 9 }
 
    /// добавить по вкусу ...
};
 
///----------------------------------------------------------------------------|
/// Старт-тест.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    for(int i = 0; i < sizeof(E)/sizeof(*E); ++i)
    {   E[i].info();
    }   std::cout << "\n";
 
    std::cin.get();
}

@GmosseN · 15.04.2020, 15:37 **[ТС]**

Сообщение от XLAT

почему сначала автор пишет 100500 строк кода,
а потом не может понять где у него не работает?

XLAT, Я разобрался в коде но не могу его доработать, что бы он учитывал все элементы.

Сообщение от XLAT

Можно же написать простые компактные куски идиоматного кода,
тщательно их протестировать, а затем уже увеличить масштаб?

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

Сообщение от XLAT

вот вполне достачно для хранения всех нужных данных

За это спасибо большое)

@XLAT · 15.04.2020, 20:11

Сообщение от XLAT

это лишняя сущность.

я всё же добавил "лишнюю сущность", а именно для того чтобы сделать быстрый(бинарный поиск из коропки)
с помощью мапы:

C++

///----------------------------------------------------------------------------|
/// С++11
/// Общая молекулярная масса, Химия C++.
///----------------------------------------------------------------------------:
#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <iomanip>
 
#define LOG(v)  std::cout << #v << " = " << v << "\n";
 
struct Chemistry
{   std::string   name;
    std::string  rname;
    std::string idname;
    int m[4];
 
    void info()
    {   std::cout << std::setw(12) << name   << "  "
                  << std::setw(10) << rname  << "  "
                  << std::setw(5)  << idname << "\t\t";
        for(int j = 0; j < 4; j++)
        {   std::cout << m[j] << "\t";
        }   std::cout         << "\n";
    }
}
 
E[] =
{   { "Hydrogenium"  , "Водород"  , "H"   ,  1,  1, 1,  1 },
    { "Helium"       , "Гелий"    , "He"  ,  2, 18, 1,  4 },
    { "Lithium"      , "Литий"    , "Li"  ,  3,  1, 2,  6 },
    { "Beryllium"    , "Бериллий" , "Be"  ,  4,  2, 2,  9 },
    { "Borum"        , "Бор"      , "B"   ,  5, 13, 2, 10 },
    { "Carboneum"    , "Углерод"  , "C"   ,  6, 14, 2, 12 },
    { "Nitrogenium"  , "Азот"     , "N"   ,  7, 15, 2, 14 },
    { "Oxygenium"    , "Кислород" , "O"   ,  8, 16, 2, 16 },
    { "Fluorum"      , "Фтор"     , "F"   ,  9, 17, 2, 18 },
    { "Neon"         , "Неон"     , "Ne"  , 10, 18, 2, 20 },
    { "Natrium"      , "Натрий"   , "Na"  , 11,  1, 3, 22 },
    { "Magnesium"    , "Магний"   , "Mg"  , 12,  2, 3, 24 },
    { "Aluminium"    , "Алюминий" , "Al"  , 13, 13, 3, 26 },
    { "Silicium"     , "Кремний"  , "Si"  , 14, 14, 3, 28 },
    { "Phosphorus"   , "Фосфор"   , "P"   , 15, 15, 3, 30 },
    { "Sulphur"      , "Сера"     , "S"   , 16, 16, 3, 32 },
    { "Chlorum"      , "Хлор"     , "Cl"  , 17, 17, 3, 35 }
 
    /// добавить по вкусу ...
};
const size_t AMOUNT = sizeof(E)/sizeof(*E);
 
///----------------------------------------------------------------------------|
/// Чтобы ускорить поиск понадобится <map>.
///----------------------------------------------------------------------------:
struct  sBase
{   sBase(Chemistry* h)
    {   for(int i = 0; i < AMOUNT; i++)
        {   b[h[i].idname] = &h[i];
        }
    }
 
    std::map<std::string, Chemistry*> b;
 
    void info()
    {   std::cout << "А вот все отсортированно-----------------------------:\n";
        for (auto it = b.begin(); it != b.end(); it++)
        {   it->second->info();
        }   std::cout  << "\n";
    }
 
    Chemistry* get(std::string key)
    {   auto it = b.find(key);
        if(it != b.end()) return it->second;
        std::cout << "ERROR: Элемент [" << key << "] не найден!\n\n";
        return nullptr;
    }
};
 
///----------------------------------------------------------------------------|
/// Парсер.
///     Правила(Химический элемент состоит из):
///         -   1 или две буквы
///         -   Первая буква заглавная
///         -   Вторая, если есть, то мелкая
///         -   После букв может идти число
///         -   Если числа нет, то принимается 1
///----------------------------------------------------------------------------:
struct  sParse
{       sParse(std::string& _s, sBase& _b) : s(_s), b(_b)
        {   go();
        }
        const std::string& s;
        sBase&             b;
        
private:
    struct  sAtom
    {       sAtom() : n(0){}
        Chemistry*  h;
        std::string e;
        int         n;
    };
    std::vector<sAtom> m;
    bool go()
    {   std::string temp;
        int cnt = 0;
        for(size_t i = 0; i < s.size(); i++)
        {   
            if(isupper(s[i]) && (cnt == 0))
            {   temp += s[i];
                cnt++;
            }
            else if(islower(s[i]) && (cnt == 1))
            {   temp += s[i];
                cnt++;
            }
            else if (isdigit(s[i]))
            {   if(!set(temp)) return false;
                m.back().n = int(convert_str_to_double(s.c_str() + i, i));
                
                temp.clear();
                cnt = 0;
                i--;
            }
            else if(cnt > 0)
            {   if(!set(temp)) return false;
                m.back().n = 1;
                
                temp.clear();
                cnt = 0;
                i--;
            }
            else
            {   std::cout << "ERROR: Ошибка в формуле: ["
                          << s << "]\n";
            }
            
            if((i == s.size()-1) && cnt != 0)
            {   if(!set(temp)) return false;
                m.back().n = 1;
            }
        }
        return true;
    }
    
    bool set(std::string& ss)
    {   m.push_back(sAtom());
        auto p = b.get(ss);
        if(p)
        {   m.back().e = ss;
            m.back().h = p;
        }
        else return false;
             return true;
    }
    
    double convert_str_to_double(const char* _s, size_t& i)
    {   char*   ptrEnd;
        double number  = strtod (_s, &ptrEnd);
        i += ptrEnd - _s;
        return number;
    }
 
public:
    void info()
    {   std::cout << "Parse====================================: " << s << "\n";
        for(auto e : m)
        {   std::cout << e.e << e.n << "\n";
        }   std::cout               << "\n";
        for(auto e : m)
        {   std::cout << e.h->rname << "\n";
        }   std::cout               << "\n";
    }
    
    double get_molecular_weight()
    {   double res = 0.;
        for(const auto& e : m)
        {   res += e.h->m[3] * e.n;
        }
        return res;
    }
};
 
///----------------------------------------------------------------------------|
/// Задача поиска Молекулярной массы по химическлй формуле.
///----------------------------------------------------------------------------:
struct sTask
{   std::string ch;
    sParse   parse;
    
    sTask(const char* _s, sBase& b) : ch(_s), parse(ch, b)
    {   std::cout   << "Жми ENTER чтобы продолжить!\n";
        std::cin.get();
        parse.info();
        std::cout   << "///--------------------------------------|\n"
                    << "/// Молекулярная масса [" << ch << "] = " 
                    << parse.get_molecular_weight() << "\n"
                    << "///--------------------------------------|\n\n";
    }
};
 
///----------------------------------------------------------------------------|
/// Старт-тест.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    for(int i = 0; i < AMOUNT; ++i)
    {   E[i].info();
    }   std::cout << "\n";
    
    sBase base(E);
                
    {   sTask task("SO",        base); }
    {   sTask task("SO4",       base); }
    {   sTask task("HeH2Li5Be", base); }
    
    std::cout   << "ПРОГРАММА ЗАВЕРШЕНА!\n";
    std::cin.get();
}

Тест:

писал, как эскимос песню поёт: т.е. можно улучшить код.

вам осталось добавить(думаю это лекго) остальные элементы в массив и сделть суровый тест ...

@XLAT · 15.04.2020, 20:59

Так формула на входе может содержать белиберду,
то вот тут я чуть-чуть поборолся за устойчивость программы:

C++

///----------------------------------------------------------------------------|
/// С++11
/// Общая молекулярная масса, Химия C++.
///----------------------------------------------------------------------------:
#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <iomanip>
 
#define LOG(v)  std::cout << #v << " = " << v << "\n";
 
struct Chemistry
{   std::string   name;
    std::string  rname;
    std::string idname;
    int m[4];
 
    void info()
    {   std::cout << std::setw(12) << name   << "  "
                  << std::setw(10) << rname  << "  "
                  << std::setw(5)  << idname << "\t\t";
        for(int j = 0; j < 4; j++)
        {   std::cout << m[j] << "\t";
        }   std::cout         << "\n";
    }
}
 
E[] =
{   { "Hydrogenium"  , "Водород"  , "H"   ,  1,  1, 1,  1 },
    { "Helium"       , "Гелий"    , "He"  ,  2, 18, 1,  4 },
    { "Lithium"      , "Литий"    , "Li"  ,  3,  1, 2,  6 },
    { "Beryllium"    , "Бериллий" , "Be"  ,  4,  2, 2,  9 },
    { "Borum"        , "Бор"      , "B"   ,  5, 13, 2, 10 },
    { "Carboneum"    , "Углерод"  , "C"   ,  6, 14, 2, 12 },
    { "Nitrogenium"  , "Азот"     , "N"   ,  7, 15, 2, 14 },
    { "Oxygenium"    , "Кислород" , "O"   ,  8, 16, 2, 16 },
    { "Fluorum"      , "Фтор"     , "F"   ,  9, 17, 2, 18 },
    { "Neon"         , "Неон"     , "Ne"  , 10, 18, 2, 20 },
    { "Natrium"      , "Натрий"   , "Na"  , 11,  1, 3, 22 },
    { "Magnesium"    , "Магний"   , "Mg"  , 12,  2, 3, 24 },
    { "Aluminium"    , "Алюминий" , "Al"  , 13, 13, 3, 26 },
    { "Silicium"     , "Кремний"  , "Si"  , 14, 14, 3, 28 },
    { "Phosphorus"   , "Фосфор"   , "P"   , 15, 15, 3, 30 },
    { "Sulphur"      , "Сера"     , "S"   , 16, 16, 3, 32 },
    { "Chlorum"      , "Хлор"     , "Cl"  , 17, 17, 3, 35 }
 
    /// добавить по вкусу ...
};
const size_t AMOUNT = sizeof(E)/sizeof(*E);
 
///----------------------------------------------------------------------------|
/// Чтобы ускорить поиск понадобится <map>.
///----------------------------------------------------------------------------:
struct  sBase
{   sBase(Chemistry* h)
    {   for(int i = 0; i < AMOUNT; i++)
        {   b[h[i].idname] = &h[i];
        }
    }
 
    std::map<std::string, Chemistry*> b;
 
    void info()
    {   std::cout << "А вот все отсортированно-----------------------------:\n";
        for (auto it = b.begin(); it != b.end(); it++)
        {   it->second->info();
        }   std::cout  << "\n";
    }
 
    Chemistry* get(std::string key)
    {   auto it = b.find(key);
        if(it != b.end()) return it->second;
        std::cout << "ERROR: Элемент [" << key << "] не найден!\n\n";
        return NULL;
    }
};
 
///----------------------------------------------------------------------------|
/// Парсер.
///     Правила(Химический элемент состоит из):
///         -   1 или две буквы
///         -   Первая буква заглавная
///         -   Вторая, если есть, то мелкая
///         -   После букв может идти число
///         -   Если числа нет, то принимается 1
///----------------------------------------------------------------------------:
struct  sParse
{       sParse(std::string& _s, sBase& _b) : s(_s), b(_b)
        {   error = !go();
        }
        const std::string& s;
        sBase&             b;
        bool           error;
        
private:
    struct  sAtom
    {       sAtom() : n(0){}
        Chemistry*  h;
        std::string e;
        int         n;
    };
    std::vector<sAtom> m;
    bool go()
    {   std::string temp;
        int cnt = 0;
        for(size_t i = 0; i < s.size(); i++)
        {   
            if(isupper(s[i]) && (cnt == 0))
            {   temp += s[i];
                cnt++;
            }
            else if(islower(s[i]) && (cnt == 1))
            {   temp += s[i];
                cnt++;
            }
            else if (isdigit(s[i]))
            {   if(!set(temp)) return false;
                m.back().n = int(convert_str_to_double(s.c_str() + i, i));
                
                temp.clear();
                cnt = 0;
                i--;
            }
            else if(cnt > 0)
            {   if(!set(temp)) return false;
                m.back().n = 1;
                
                temp.clear();
                cnt = 0;
                i--;
            }
            else
            {   std::cout << "ERROR: Ошибка в формуле: ["
                          << s << "]\n";
                return false;
            }
            
            if((i == s.size()-1) && cnt != 0)
            {   if(!set(temp)) return false;
                m.back().n = 1;
            }
        }
        return true;
    }
    
    bool set(std::string& ss)
    {   m.push_back(sAtom());
        auto p = b.get(ss);
        if(p)
        {   m.back().e = ss;
            m.back().h = p;
        }
        else return false;
             return true;
    }
    
    double convert_str_to_double(const char* _s, size_t& i)
    {   char*   ptrEnd;
        double number  = strtod (_s, &ptrEnd);
        i += ptrEnd - _s;
        return number;
    }
 
public:
    void info()
    {   std::cout << "Parse====================================: " << s << "\n";
        if(error) return;
        
        for(auto e : m)
        {   std::cout << e.e << e.n << "\n";
        }   std::cout               << "\n";
        for(auto e : m)
        {   std::cout << e.h->rname << "\n";
        }   std::cout               << "\n";
    }
    
    double get_molecular_weight()
    {   double res = 0.;
        for(const auto& e : m)
        {   res += e.h->m[3] * e.n;
        }
        return res;
    }
};
 
///----------------------------------------------------------------------------|
/// Задача поиска Молекулярной массы по химическлй формуле.
///----------------------------------------------------------------------------:
struct sTask
{   std::string ch;
    
    sTask(const char* _s, sBase& b) : ch(_s)
    {   std::cout   << "Жми ENTER чтобы продолжить!\n";
        std::cin.get();
        
        sParse parse(ch, b);
               parse.info();
        if(parse.error)
        {   std::cout   << "ERROR: Проверьте вашу формулу!\n";
            return;
        }
        std::cout   << "///--------------------------------------|\n"
                    << "/// Молекулярная масса [" << ch << "] = " 
                    << parse.get_molecular_weight() << "\n"
                    << "///--------------------------------------|\n\n";
    }
};
 
///----------------------------------------------------------------------------|
/// Старт-тест.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    for(int i = 0; i < AMOUNT; ++i)
    {   E[i].info();
    }   std::cout << "\n";
    
    sBase base(E);
               
    {   sTask task("SO",        base); }
    {   sTask task("SO4",       base); }
    {   sTask task("HeH2Li5Be", base); }
    {   sTask task("XXYYZZ",    base); } 
    
    std::cout   << "ПРОГРАММА ЗАВЕРШЕНА!\n";
    std::cin.get();
}

В общем тестите.

Ещё раз:
щас задача, защитить этот калькулятор от неверных входных данных.
собсно и упор теста на это.
Все мои тесты это вот те четыре сроки.

@GmosseN · 15.04.2020, 21:01 **[ТС]**

XLAT, Благодарю за помощь. Вы меня очень выручили. Делаю курсовую. Еще раз спасибо)

@tasha_mirdr · 14.07.2020, 16:45

Добавлено через 35 минут

Сообщение от XLAT

Так формула на входе может содержать белиберду,
то вот тут я чуть-чуть поборолся за устойчивость программы:

C++

///----------------------------------------------------------------------------|
/// С++11
/// Общая молекулярная масса, Химия C++.
///----------------------------------------------------------------------------:
#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <iomanip>
 
#define LOG(v)  std::cout << #v << " = " << v << "\n";
 
struct Chemistry
{   std::string   name;
    std::string  rname;
    std::string idname;
    int m[4];
 
    void info()
    {   std::cout << std::setw(12) << name   << "  "
                  << std::setw(10) << rname  << "  "
                  << std::setw(5)  << idname << "\t\t";
        for(int j = 0; j < 4; j++)
        {   std::cout << m[j] << "\t";
        }   std::cout         << "\n";
    }
}
 
E[] =
{   { "Hydrogenium"  , "Водород"  , "H"   ,  1,  1, 1,  1 },
    { "Helium"       , "Гелий"    , "He"  ,  2, 18, 1,  4 },
    { "Lithium"      , "Литий"    , "Li"  ,  3,  1, 2,  6 },
    { "Beryllium"    , "Бериллий" , "Be"  ,  4,  2, 2,  9 },
    { "Borum"        , "Бор"      , "B"   ,  5, 13, 2, 10 },
    { "Carboneum"    , "Углерод"  , "C"   ,  6, 14, 2, 12 },
    { "Nitrogenium"  , "Азот"     , "N"   ,  7, 15, 2, 14 },
    { "Oxygenium"    , "Кислород" , "O"   ,  8, 16, 2, 16 },
    { "Fluorum"      , "Фтор"     , "F"   ,  9, 17, 2, 18 },
    { "Neon"         , "Неон"     , "Ne"  , 10, 18, 2, 20 },
    { "Natrium"      , "Натрий"   , "Na"  , 11,  1, 3, 22 },
    { "Magnesium"    , "Магний"   , "Mg"  , 12,  2, 3, 24 },
    { "Aluminium"    , "Алюминий" , "Al"  , 13, 13, 3, 26 },
    { "Silicium"     , "Кремний"  , "Si"  , 14, 14, 3, 28 },
    { "Phosphorus"   , "Фосфор"   , "P"   , 15, 15, 3, 30 },
    { "Sulphur"      , "Сера"     , "S"   , 16, 16, 3, 32 },
    { "Chlorum"      , "Хлор"     , "Cl"  , 17, 17, 3, 35 }
 
    /// добавить по вкусу ...
};
const size_t AMOUNT = sizeof(E)/sizeof(*E);
 
///----------------------------------------------------------------------------|
/// Чтобы ускорить поиск понадобится <map>.
///----------------------------------------------------------------------------:
struct  sBase
{   sBase(Chemistry* h)
    {   for(int i = 0; i < AMOUNT; i++)
        {   b[h[i].idname] = &h[i];
        }
    }
 
    std::map<std::string, Chemistry*> b;
 
    void info()
    {   std::cout << "А вот все отсортированно-----------------------------:\n";
        for (auto it = b.begin(); it != b.end(); it++)
        {   it->second->info();
        }   std::cout  << "\n";
    }
 
    Chemistry* get(std::string key)
    {   auto it = b.find(key);
        if(it != b.end()) return it->second;
        std::cout << "ERROR: Элемент [" << key << "] не найден!\n\n";
        return NULL;
    }
};
 
///----------------------------------------------------------------------------|
/// Парсер.
///     Правила(Химический элемент состоит из):
///         -   1 или две буквы
///         -   Первая буква заглавная
///         -   Вторая, если есть, то мелкая
///         -   После букв может идти число
///         -   Если числа нет, то принимается 1
///----------------------------------------------------------------------------:
struct  sParse
{       sParse(std::string& _s, sBase& _b) : s(_s), b(_b)
        {   error = !go();
        }
        const std::string& s;
        sBase&             b;
        bool           error;
        
private:
    struct  sAtom
    {       sAtom() : n(0){}
        Chemistry*  h;
        std::string e;
        int         n;
    };
    std::vector<sAtom> m;
    bool go()
    {   std::string temp;
        int cnt = 0;
        for(size_t i = 0; i < s.size(); i++)
        {   
            if(isupper(s[i]) && (cnt == 0))
            {   temp += s[i];
                cnt++;
            }
            else if(islower(s[i]) && (cnt == 1))
            {   temp += s[i];
                cnt++;
            }
            else if (isdigit(s[i]))
            {   if(!set(temp)) return false;
                m.back().n = int(convert_str_to_double(s.c_str() + i, i));
                
                temp.clear();
                cnt = 0;
                i--;
            }
            else if(cnt > 0)
            {   if(!set(temp)) return false;
                m.back().n = 1;
                
                temp.clear();
                cnt = 0;
                i--;
            }
            else
            {   std::cout << "ERROR: Ошибка в формуле: ["
                          << s << "]\n";
                return false;
            }
            
            if((i == s.size()-1) && cnt != 0)
            {   if(!set(temp)) return false;
                m.back().n = 1;
            }
        }
        return true;
    }
    
    bool set(std::string& ss)
    {   m.push_back(sAtom());
        auto p = b.get(ss);
        if(p)
        {   m.back().e = ss;
            m.back().h = p;
        }
        else return false;
             return true;
    }
    
    double convert_str_to_double(const char* _s, size_t& i)
    {   char*   ptrEnd;
        double number  = strtod (_s, &ptrEnd);
        i += ptrEnd - _s;
        return number;
    }
 
public:
    void info()
    {   std::cout << "Parse====================================: " << s << "\n";
        if(error) return;
        
        for(auto e : m)
        {   std::cout << e.e << e.n << "\n";
        }   std::cout               << "\n";
        for(auto e : m)
        {   std::cout << e.h->rname << "\n";
        }   std::cout               << "\n";
    }
    
    double get_molecular_weight()
    {   double res = 0.;
        for(const auto& e : m)
        {   res += e.h->m[3] * e.n;
        }
        return res;
    }
};
 
///----------------------------------------------------------------------------|
/// Задача поиска Молекулярной массы по химическлй формуле.
///----------------------------------------------------------------------------:
struct sTask
{   std::string ch;
    
    sTask(const char* _s, sBase& b) : ch(_s)
    {   std::cout   << "Жми ENTER чтобы продолжить!\n";
        std::cin.get();
        
        sParse parse(ch, b);
               parse.info();
        if(parse.error)
        {   std::cout   << "ERROR: Проверьте вашу формулу!\n";
            return;
        }
        std::cout   << "///--------------------------------------|\n"
                    << "/// Молекулярная масса [" << ch << "] = " 
                    << parse.get_molecular_weight() << "\n"
                    << "///--------------------------------------|\n\n";
    }
};
 
///----------------------------------------------------------------------------|
/// Старт-тест.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
    for(int i = 0; i < AMOUNT; ++i)
    {   E[i].info();
    }   std::cout << "\n";
    
    sBase base(E);
               
    {   sTask task("SO",        base); }
    {   sTask task("SO4",       base); }
    {   sTask task("HeH2Li5Be", base); }
    {   sTask task("XXYYZZ",    base); } 
    
    std::cout   << "ПРОГРАММА ЗАВЕРШЕНА!\n";
    std::cin.get();
}

В общем тестите.

Ещё раз:
щас задача, защитить этот калькулятор от неверных входных данных.
собсно и упор теста на это.
Все мои тесты это вот те четыре сроки.

Добрый день!
А что добавить для более сложных формул:
например:
Mg(NO3)2 здесь количество Mg=1. N=2. O=3*2=6
и еще интереснее
K3[Fe(CN)6] здесь K=3, Fe=1, C=6, N=6
[Ag(NH3)2]OH здесь Ag=1 N=2 H=6+1=7 O=1

Добавлено через 59 минут
XLAT, помогите, пожадуйста

@XLAT · 14.07.2020, 18:45

Сообщение от tasha_mirdr

Mg(NO3)2 здесь количество Mg=1. N=2. O=3*2=6
и еще интереснее
K3[Fe(CN)6] здесь K=3, Fe=1, C=6, N=6
[Ag(NH3)2]OH здесь Ag=1 N=2 H=6+1=7 O=1

это эквивалентно такому:

Код

Mg(NO3)2     -> Mg + (N + O * 3) * 2
K3[Fe(CN)6]  -> K * 3 + (Fe + (C + N) * 6)
[Ag(NH3)2]OH -> (Ag + (N + H * 3) * 2) + O + H

Буквы здесь есть хим.элементы которые нужно заменить численными значениями которые выражают молекулярную массу.
Далее тупо: это калькулятор - самый обычный калькулятор:
Сделать калькулятор арифметического выражения

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

@tasha_mirdr · 14.07.2020, 22:40

СПАСИБО, попробую, я все-таки больше химик, чем программист, надеюсь не буду тупить

Добавлено через 1 час 14 минут
в самом начале стоп у меня:
мне же нужно формулы вводить и простые SO3 и Mg(NO3)2 и т.д. и вначале их нужно преобразовать в арифм выражение

@XLAT · 14.07.2020, 22:52

Сообщение от tasha_mirdr

и вначале их нужно преобразовать в арифм выражение

это так и
это соль любого программирования: БОЛЬШАЯ ЗАДАЧА РАЗБИВАЕТСЯ НА МНОЖЕСТВО МЕЛКИХ ЗАДАЧ.

под другому не бывает

разбиваете общую задачу до тех пор, пока не появляется возможность написать решение уже на целевом ЯПе.

@XLAT · 16.07.2020, 21:39

Сообщение от XLAT

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

C++

///----------------------------------------------------------------------------|
/// С++11
/// Общая молекулярная масса, Химия C++.
///----------------------------------------------------------------------------:
#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <map>
#include <iomanip>
 
#define LOG(v)  std::cout << #v << " = " << v << "\n";
#define BANNER(v1,v2,v3) std::cout << v1 << "\n" << v2 << "\n" << v3 << "\n";
 
template <typename T>
std::string toString(T val)
{   std::ostringstream oss;
    oss << val;
    return oss.str();
}
 
///----------------------------------------------------------------------------|
/// Таблица Д.И.Менделеева.
///----------------------------------------------------------------------------:
struct Chemistry
{   std::string   name;
    std::string  rname;
    std::string idname;
    int m[3];
    double M;
 
    void info()
    {   std::cout << std::setw(12) << name   << "  "
                  << std::setw(10) << rname  << "  "
                  << std::setw(5)  << idname << "\t\t";
        for(int i = 0; i < 3; i++)
        {   std::cout << m[i] << "\t";
        }
        std::cout << M    << "\n";
    }
}
 
E[] =
{   { "Hydrogenium"  , "Водород"  , "H"   ,  1,  1, 1,  1.008   },
    { "Helium"       , "Гелий"    , "He"  ,  2, 18, 1,  4       },
    { "Lithium"      , "Литий"    , "Li"  ,  3,  1, 2,  6       },
    { "Beryllium"    , "Бериллий" , "Be"  ,  4,  2, 2,  9       },
    { "Borum"        , "Бор"      , "B"   ,  5, 13, 2, 10       },
    { "Carboneum"    , "Углерод"  , "C"   ,  6, 14, 2, 12.011   },
    { "Nitrogenium"  , "Азот"     , "N"   ,  7, 15, 2, 14.007   },
    { "Oxygenium"    , "Кислород" , "O"   ,  8, 16, 2, 15.999   },
    { "Fluorum"      , "Фтор"     , "F"   ,  9, 17, 2, 18       },
    { "Neon"         , "Неон"     , "Ne"  , 10, 18, 2, 20       },
    { "Natrium"      , "Натрий"   , "Na"  , 11,  1, 3, 22       },
    { "Magnesium"    , "Магний"   , "Mg"  , 12,  2, 3, 24.312   },
    { "Aluminium"    , "Алюминий" , "Al"  , 13, 13, 3, 26       },
    { "Silicium"     , "Кремний"  , "Si"  , 14, 14, 3, 28       },
    { "Phosphorus"   , "Фосфор"   , "P"   , 15, 15, 3, 30       },
    { "Sulphur"      , "Сера"     , "S"   , 16, 16, 3, 32       },
    { "Chlorum"      , "Хлор"     , "Cl"  , 17, 17, 3, 35       },
    { "Argon"        , "Аргон"    , "Ar"  , 18, 18, 3, 38       },
    { "Kalium"       , "Калий"    , "K"   , 19,  1, 4, 39.102   },
    { "Calcium"      , "Кальций"  , "Ca"  , 20,  2, 4, 40       },
    { "Scandium"     , "Скандий"  , "Sc"  , 21,  3, 4, 44       },
    { "Titanium"     , "Титан"    , "Ti"  , 22,  4, 4, 47       },
    { "Vanadium"     , "Ванадий"  , "V"   , 23,  5, 4, 50       },
    { "Chromium"     , "Хром"     , "Cr"  , 24,  6, 4, 52       },
    { "Manganum"     , "Марганец" , "Mn"  , 25,  7, 4, 55       },
    { "Ferrum"       , "Железо"   , "Fe"  , 26,  8, 4, 55.849   },
    { "Cobaltum"     , "Кобальт"  , "Co"  , 27,  9, 4, 59       },
    { "Niccolum"     , "Никель"   , "Ni"  , 28, 10, 4, 58       },
    { "Cuprum"       , "Медь"     , "Cu"  , 29, 11, 4, 63       },
    { "Zincum"       , "Цинк"     , "Zn"  , 30, 12, 4, 65       },
    { "Gallium"      , "Галлий"   , "Ga"  , 31, 13, 4, 69       },
    { "Germanium"    , "Германий" , "Ge"  , 32, 14, 4, 72       },
    { "Arsenicum"    , "Мышьяк"   , "As"  , 33, 15, 4, 74       },
    { "Selenium"     , "Селен"    , "Se"  , 34, 16, 4, 78       },
    { "Bromum"       , "Бром"     , "Br"  , 35, 17, 4, 79       },
    { "Krypton"      , "Криптон"  , "Kr"  , 36, 18, 4, 83       },
    { "Rubidium"     , "Рубидий"  , "Rb"  , 37,  1, 4, 85       },
    { "Strontium"    , "Стронций" , "Sr"  , 38,  2, 1, 87       },
    { "Yttrium"      , "Иттрий"   , "Y"   , 39,  3, 5, 88       },
    { "Zirconium"    , "Цирконий" , "Zr"  , 40,  4, 5, 91       },
    { "Niobium"      , "Ниобий"   , "Nb"  , 41,  4, 5, 92       },
    { "Molybdaenum"  , "Молибден" , "Mo"  , 42,  5, 5, 95       },
    { "Technetium"   , "Технеций" , "Tc"  , 43,  7, 5, 98       },
    { "Ruthenium"    , "Рутений"  , "Ru"  , 44,  8, 5, 101      },
    { "Rhodium"      , "Родий"    , "Rh"  , 45,  9, 5, 102      },
    { "Palladium"    , "Палладий" , "Rd"  , 46, 10, 5, 106      },
    { "Argentum"     , "Серебро"  , "Ag"  , 47, 11, 5, 107.868  }
 
    /// добавить по вкусу ...
};
const size_t AMOUNT = sizeof(E)/sizeof(*E);
 
///-----------------------------------------|
/// Чтобы ускорить поиск понадобится <map>. |
///-----------------------------------------:
struct  sBase
{   sBase(Chemistry* h)
    {   for(int i = 0; i < AMOUNT; i++)
        {   b[h[i].idname] = &h[i];
        }
    }
 
    Chemistry* get(const std::string& key)
    {   auto it  = b.find(key);
        if(  it != b.end()) return it->second;
 
        std::string err("ERROR: Элемент \"");
        err += key + "\" не найден!";
        throw       err;
 
        return NULL;
    }
 
private:
    std::map<std::string, Chemistry*> b;
} tab_Mendeleev(E);
 
///----------------------------------------------------------------------------|
/// Подготовка строки с формулой для подачи в калькулятор.
///----------------------------------------------------------------------------:
///------------------|
/// Режимы.          |
///------------------:
enum eMODE
{   E_NUM_ATOM,      // Для подсчёта кол-ва атомов в формуле.
    E_MOL_MASS       // Для подсчёта молекулярной массы.
}   MODE = E_MOL_MASS;
 
struct  Convert_to_calculator
{   Convert_to_calculator(std::string& s)
    {   go(s);
    }
 
private:
    void go(std::string& s)
    {   if(!is_good_brace(s)) throw "ERROR: Нарушение порядка скобок!";
 
        std::string    d;
        std::string    e;
        int cnt_atom = 0;
 
        for(size_t i = 0; i < s.size(); i++)
        {   char&  c = s[i];
            switch(c)
            {   case '(':
                case '[':
                {   d += '(';
                    break;
                }
 
                case ')':
                case ']':
                {   d.back() = ')';
                    if(i != s.size()-1) d += '+';
                    break;
                }
 
                default:
                {   if(isupper(c))
                    {   ///----------------------------------------|
                        /// Извлечение имени элемента.             |
                        ///----------------------------------------:
                        std::string ss = get_str_elem(s.c_str(), i);
 
                        if(MODE == E_MOL_MASS)
                        {   ///------------------------------------|
                            /// Получение доступа к инфе элементе. |
                            ///------------------------------------:
                            Chemistry*  p  = tab_Mendeleev.get(ss);
 
                            ///------------------------------------|
                            /// Добавить к приёмнику строки числа, |
                            /// выражающего молекулярную массу.    |
                            ///------------------------------------:
                            d += toString(p->M);
                        }
                        else
                        {   ///------------------------------------|
                            /// Режим подсчета кол-ва атомов.      |
                            ///------------------------------------:
                            d += toString(1.);
                        }
                    }
                    else if(isdigit(c))
                    {   if(d.back() == '+') d.back() = '*';
                        else                d       += '*';
 
                        ///----------------------------------------|
                        /// Извлечение числа кол-ва атомов.        |
                        ///----------------------------------------:
                        get_str_digit(s, d, i);
                    }
                    else
                    {   throw "ERROR: Недопустимый символ!";
                    }
                    if(i != s.size()-1) d += '+';
                }
            }
        }
        std::swap(d, s);
    }
 
    ///------------------------------------------------------------------------|
    /// Вспомогательные функции.
    ///------------------------------------------------------------------------:
    std::string get_str_elem(const char* s, size_t& i)
    {   std::string d(1, s[i]);
 
        while(s[++i] != 0)
        {   if(islower(s[i])) d += s[i];
            else break;
        }
        i--;
        return d;
    }
 
    void get_str_digit(std::string& s, std::string& d, size_t& i)
    {   d  += s[i++];
        for(; s[i] != 0;  i++)
        {   if(isdigit(s[i]) || s[i] == '.') d += s[i];
            else break;
        }
        i--;
    }
 
    bool is_good_brace(const std::string& str)
    {   std::stack<char> st;
 
        char  m[128];
        m[')'] = '(';
        m[']'] = '[';
        m['}'] = '{';
 
        for(const auto c : str)
        {   if     (c=='(' || c=='[' || c=='{')      st.push(c);
            else if(c==')' || c==']' || c=='}')
            {   if(st.empty() || st.top() != m[c]) return false;
                st.pop();
            }
        }
        return st.empty();
    }
};
 
///----------------------------------------------------------------------------|
/// Школьный калькулятор на 4 действия.
///----------------------------------------------------------------------------:
#include <deque>
class Calculator
{
private:
    class  smycin
    {
    public:
        void set(const std::string& s)
        {   d.clear();
            for(const auto& e : s)
            {   d.push_back(e);
            }
            //info();
        }
 
        void putback(char c)
        {   d.push_front(c);
        }
 
        char get()
        {   if(d.empty()) return 0;
            char c = d.front();
            d.pop_front();
            return c;
        }
 
    private:
        std::deque<char> d;
        void info()
        {   for(size_t i = 0; i < d.size(); i++)
                std::cout << d[i];
            std::cout << "\n";
        }
    } my;
 
    double number()
    {   double res = 0;
        int    m   = 1;
        bool   b   = false;
        for (;;)
        {   char c = my.get();
            if (c >= '0' && c <= '9')
            {   res = res *  10 + (c - '0');
                if(b) m   *= 10;
            }
            else if (c == '.') b = true;
            else
            {   my.putback(c);
                return res/m;
            }
        }
    }
 
    double skobki()
    {   char c = my.get();
        if (c == '(')
        {   double x = expr();
            my.get();
            return x;
        }
        else
        {   my.putback(c);
            return number();
        }
    }
 
    double factor()
    {   double x = skobki();
        for (;;)
        {   char c = my.get();
            switch (c)
            {   case '*':
                    x *= skobki();
                    break;
                case '/':
                    x /= skobki();
                    break;
                default:
                    my.putback(c);
                    return x;
            }
        }
    }
 
    double expr()
    {   double x = factor();
        for (;;)
        {   char c = my.get();
            switch (c)
            {   case '+':
                    x += factor();
                    break;
                case '-':
                    x -= factor();
                    break;
                default:
                    my.putback(c);
                    return x;
            }
        }
    }
 
public:
    ///---------------------------------------------|
    /// Это тут всё!                                |
    /// Что ты должен знать об этом калькуляторе!!! |
    ///---------------------------------------------:
    double res;
    double go(std::string str)
    {   std::cout << "Выражение: " << str;
        my.set(str);
        res = expr();
        std::cout << " = " << std::setprecision(15) << res << std::endl;
        return res;
    }
};
 
///----------------------------------------------------------------------------|
/// Вся задача здесь.
///----------------------------------------------------------------------------:
struct sTask
{   double result;
    std::string str_for_calc;
 
    sTask(const char* S) : str_for_calc(S)
    {   try
        {   
            MODE = E_MOL_MASS;
            std::cout                   << str_for_calc << " -> ";
            std::cout << "\nМолярная масса: ";
            {   Convert_to_calculator conv(str_for_calc);
            }
            
            Calculator calc;
            result   = calc.go(str_for_calc.c_str());
            
            std::cout << "Всего атомов  : ";
            MODE = E_NUM_ATOM;
                                           str_for_calc = std::string(S);
            {   Convert_to_calculator conv(str_for_calc);
            }
            calc.go(str_for_calc.c_str());
            
        }
        catch(const std::string& err)
        {   std::cout << err;
        }
        catch(const char* err)
        {   std::cout << err;
        }
        std::cout << "\n\n";
    }
};
 
///----------------------------------------------------------------------------|
/// Тест.
///----------------------------------------------------------------------------:
int main()
{   setlocale(0, "");
 
                             BANNER(
    "///-------------------------|",
    "/// Тест.                   |",
    "///-------------------------:")
    {   sTask task("Mg(NO3)2"    );}
    {   sTask task("K3[Fe(CN)6]" );}
    {   sTask task("[Ag(NH3)2]OH");}
 
                             BANNER(
    "///-------------------------|",
    "/// Тест ошибок.            |",
    "///-------------------------:")
    {   sTask task("Hx[Al(OH)2]3" ); // Нет такого элемента.
    }
    {   sTask task("H:[Al(OH)2]3" ); // Недопустимый символ.
    }
    {   sTask task("H(Al[OH)2]3"  ); // Нарушение порядка скобок.
    }
 
    std::cin.get();
    return 0;
}

@tasha_mirdr · 17.07.2020, 12:21

Благодарю 1 млн раз

Общая молекулярная масса, Химия C++

Решение

Решение

@GmosseN 1 / 1 / 0 Регистрация: 15.04.2019 Сообщений: 41
	15.04.2020, 15:37 [ТС]	3
	Сообщение от XLAT почему сначала автор пишет 100500 строк кода, а потом не может понять где у него не работает? XLAT, Я разобрался в коде но не могу его доработать, что бы он учитывал все элементы. Сообщение от XLAT Можно же написать простые компактные куски идиоматного кода, тщательно их протестировать, а затем уже увеличить масштаб? Я в классах не понимаю почти ничего, у меня только поверхностный уровень, но задание нужно сделать. Сообщение от XLAT вот вполне достачно для хранения всех нужных данных За это спасибо большое) 0

@GmosseN 1 / 1 / 0 Регистрация: 15.04.2019 Сообщений: 41
	15.04.2020, 21:01 [ТС]	6
	XLAT, Благодарю за помощь. Вы меня очень выручили. Делаю курсовую. Еще раз спасибо) 1

@XLAT Just Do It! 3714 / 2017 / 628 Регистрация: 23.09.2014 Сообщений: 6,466 Записей в блоге: 2
	14.07.2020, 18:45	8
	Сообщение от tasha_mirdr Mg(NO3)2 здесь количество Mg=1. N=2. O=32=6 и еще интереснее K3[Fe(CN)6] здесь K=3, Fe=1, C=6, N=6 [Ag(NH3)2]OH здесь Ag=1 N=2 H=6+1=7 O=1 это эквивалентно такому: Код Mg(NO3)2 -> Mg + (N + O 3) * 2 K3[Fe(CN)6] -> K * 3 + (Fe + (C + N) * 6) [Ag(NH3)2]OH -> (Ag + (N + H * 3) * 2) + O + H Буквы здесь есть хим.элементы которые нужно заменить численными значениями которые выражают молекулярную массу. Далее тупо: это калькулятор - самый обычный калькулятор: Сделать калькулятор арифметического выражения вам тупо нужно подставить значения молекулярной массы в ваши хим.формулы и опять же тупо вызвать по ссылке тамошний калькулятор с этой сгенерированной строкой на входе для получения полного результата. 1

@tasha_mirdr 0 / 0 / 0 Регистрация: 14.07.2020 Сообщений: 3
	14.07.2020, 22:40	9
	СПАСИБО, попробую, я все-таки больше химик, чем программист, надеюсь не буду тупить Добавлено через 1 час 14 минут в самом начале стоп у меня: мне же нужно формулы вводить и простые SO3 и Mg(NO3)2 и т.д. и вначале их нужно преобразовать в арифм выражение 0

@XLAT Just Do It! 3714 / 2017 / 628 Регистрация: 23.09.2014 Сообщений: 6,466 Записей в блоге: 2
	14.07.2020, 22:52	10
	Сообщение от tasha_mirdr и вначале их нужно преобразовать в арифм выражение это так и это соль любого программирования: БОЛЬШАЯ ЗАДАЧА РАЗБИВАЕТСЯ НА МНОЖЕСТВО МЕЛКИХ ЗАДАЧ. под другому не бывает разбиваете общую задачу до тех пор, пока не появляется возможность написать решение уже на целевом ЯПе. 0

@tasha_mirdr 0 / 0 / 0 Регистрация: 14.07.2020 Сообщений: 3
	17.07.2020, 12:21	12
	Благодарю 1 млн раз 0

Опции темы