Pole s ukazateli na různé proměnné struct – C / C++ – Fórum – Programujte.com

Ahoj ve spolek, prosím o radu. 

mám několik různých struct proměnných, dejme tomu 

struct Example_1 {int item1, float item2} var_1;

struct Example_2 {unsigned long item1, int item2} var_2;

Proměnné ukládám do souboru například takto...

file1.write((uint8_t*)&var_1, sizeof(var_1));

file2.write((uint8_t*)&var_2, sizeof(var_2));

Těch proměnných mám celkem 13, s různými definicemi. Chtěl jsem zjednodušit kód a vyrobit pole s 13 prvky s ukazateli na jednotlivé proměnné, pole s 13 prvky jejich velikostí a do souborů pak ukládat ve smyčce.

Jenže netuším, jak vyrobit to pole s ukazateli. Všude nacházím příklady, kde součástí struktury je i ukazatel na ni který pak třeba naplním ukazatelem na první položku, což je sice fajn, ale to mi nepomůže ke vzniku indexovatelného pole s ukazateli na různé struktury...

struct Example_1 {int item1, float item2} var_1, *ukz_var_1;

ukz_var_1 = &var_1.item1;   

Můžete mi prosím poradit? Já ty ukazatele pořád nedokážu vstřebat.

Děkuji, Roman

https://overiq.com/c-programming-101/array-of-pointers-in-c/

hu

#2 hlucheucho
Ahoj, tohle v tom odkazu bych pochopil... 

int *arrop[3]; int a = 10, b = 20, c = 50, i; arrop[0] = &a; arrop[1] = &b; arrop[2] = &c;
 

ale to je všechno typu int... stejný typ proměnných, pole prvků ukazatelů na int.

Můj problém je, že jde o různé proměnné, různé struktury...

čili asi nemůžu udělat toto...

int *ukaz[2]; ........  ukaz[0] = &var_1; ukaz[1] = &var_2;

když var_1 a var_2 za a) není int a za b) je každá jiná struct...

Roman

Pole je homogenní útvar, všechny prvky jsou stejného typu. Pokud jsou to ukazatele na různé typy struktur, budeš je muset nejdříve přetypovat na generické (void*), ty pak ukládat do pole a při použití je zpět přetypovat na příslušný typ. Příjde mi to divoký. Jestli by nešlo ty struktury sjednotit na jeden typ nebo použít C++ a dědičnost.

hu

#4 hlucheucho
Pole je homogenní útvar,

no právě... jsem si naivně představoval, že ukazatel na cokoliv je číslo, adresa v paměti, se kterou mohu pracovat bez ohledu na to, z jaké proměnné a jakého typu vznikl...

Sjednotit to nemohu, mám to jako soft pro ovládání akva a každá struct je souborem parametrů modulu... teploměr, topení, pH sonda, spínání CO2, osvětlení...

a struct se mi hodí, protože třeba pro ten zápis do souboru na SD kartu nebo do FLASH paměti je to super, protože je to zastoupené názvem celé variably... pak mne zajímá jen délka, nestarám se o položky.

#5 rjulius
a jinak ano, je to C++... 

Co se týče ukládání dat do souboru, zvážil bych ukládání jako řetězce. Vyhneš se potížím se zarovnáváním a endianitou při zpracování souboru na různých systémech. Pak bys musel vymyslet, jak uložit data struktury, např jaho hodnoty oddělené středníkem. Každou proměnnou pak na samostatný řádek. A pak také, jak rozlišit co do které proměnné patří, např. pořadí v souboru.

V C++ bych používal Class. Společného předka, který ponese společné vlastnosti a pak potomci, kteří implementují speciality. Výhodou je, že na potomka lze ukazovat pomocí ukazatele na předka.

Každé Class lze pak implementovat samostatně metodu, která zformátuje a uloží data do souboru.  (samozřejmě jakoukoliv metodu) Zde se hodí polymorfismus.

To pak vede k myšlence vytvořit rozhraní (uložit do souboru, načíst ze souboru ...) jako společného předka s tím, že metody rozhraní budou čiré a implementovat se budou až u potomků.

hu

#7 hlucheucho
ok, no nic, každopádně děkuji za objasnění, že jsem ve slepé uličce.

Data nebudu nikam přenášet, jde pouze o lokální zálohu, která se pak obráceným postup může načíst do stejných struktur, takže každá hodnota je vždy přesně na svém místě. Čili si to ani nebudu komplikovat.

Stejně tak si to už ani nebudu komplikovat předělání celého programu na třídy, kterým za prvé nerozumím a za druhé by mi to možná přineslo výhodu jen při tom ukládání.

To tam radši nechám 13x stejný blok programu lišící se pouze názvy proměnných. Je to stupidní, ale přímočaré. Potíž je akorát, když jsem to dělal a něco měnil... pořád myslet na všechna místa, kde je to 13x použité :) Ale když ten soft nikomu neukážu, nebudu za blbce a sám se s tím nějak vyrovnám :)

float *f;
int *i;

void *ptr[2];


ptr[0] = (void*)f;
ptr[1] = (void*)i;

Příjde mi to jako bramboračka. Nauč se používat výhody C++. Objektové programování je "lidštější" než procedurální. Navíc ti některé věci jako např. dědičnost mohou usnadnit práci.

hu

#9 hlucheucho
jasný :) díky

Polymorfizmus a serializace/deserializace by ti v tomhle smeru docela pomohla...

Ale da se pouzit i protobuf od google, udelas jen definice zprav prelozis na c++ a pak uz se to da v celku dobre pouzivat: https://developers.google.com/…/cpptutorial

Nebo klidne i json - ten se take da nacist protobuf parserem a je i dobre citelny datovy soubor.

Pokud je to skolni projekt tak holt rozjet implementaci TLV (tag, length, value) - abys zvladl poznat, co ze to vlastne mas za data a kam je nacist. (pouziva se na protokoly jako SNMP a tak, takze ukazek je hodne)

#1 rjulius
to co hledáš tomu se říká kolekce :). kolekce je soubor ukazatelů :)

používá se k tomu tzv. LinkedList nebo Array nebo DoubleLinkedList nebo v tvém případě asi tzv. Dictionary

https://www.geeksforgeeks.org/data-structures/linked-list/#doublyLinkedList

https://www.delftstack.com/howto/cpp/cpp-create-a-dictionary/

Asi bych ve tvém případě použil Array aby si mohl přistupovat k jednotlivým položkám přes index "i" v cyklu for. Protože u LinkedList musíš použít složitější "enumerátor". Do array si budeš ukládat jen ukazatel na nějakou stukturu, která bude mít následující tvar:

struct Item { int Key; void* link;}

kde Key je 4 bytový identifikátor typu stuktury, na jakou ukazuje ukazatel link. No a link pak muže pro index třeba [1] ukazovat na var_1 a pro index [2] bude ukazovat na var_2 atd. .. chápeš jo ? a podle toho klíče Key už pak dynamicky přetypuješ ukazatel link abys mohl ukazovat na konkrétní strukturu

dynamic_cast<Example_1>(*link)."proměnná v Example_1"

chápeš jo ?

#12 JerryM

jinak celá ta tvoje srágora bude vypadat tak nějak zjednodušeně takhle

Item MyArray

// tady to nějak naplníš to pole

...

// a tady to zpracujes

for (int i = 0; i < 13; i++)

{

  switch MyArray[i].Key

    1: {  dynamic_cast<Example_1>(MyArray[i].link*)."proměnná v Example_1"; }

    2: {  dynamic_cast<Example_2>(MyArray[i].link*)."proměnná v Example_2";}

}// for

no .. tak nějak to bude .. chápeš jo ? :) :) :)

ještě bych doplnil několik drobností. měl by ses doučit co to je:

1/ STL  https://www.geeksforgeeks.org/…ry-stl/ ; a co obsahuje a jak se to používá, všechno tohle začínalo na konci 80 a začátku 90 let ...

2/ měl by ses doučit co je to LinkedList, DoubleLinkedList, Array, List, Queue atd ...  na tomhle je postavená celá knihovna STL,   https://www.geeksforgeeks.org/…;  ; ,   no a taky by asi bylo dobrý doučit se stromový struktury jako KDtree, Btree, RBtree atd abys věděl o co de aspoň trochu  https://www.geeksforgeeks.org/…/  ; prtotože stromový struktury sou pokračováním věcí jako je LinkedList atd.

3/ V pozdějších letech někdo vymyslel serializaci a deserializaci, tyhle věci slouží obvykle ukládání objektů nebo jejich částí (obecně dat) na nějaký nosič, obvykle disk. Serializací ukládáš aktuální stav "class" a všech proměnných v ní pokud si neurčil jinak(např. vhodným atributem nonserializable atd). serializovat mužeš přes stream i třeba na tiskárnu, ale z tiskárny už nemužeš deserializovat zpátky do paměti, čili nemužeš naplnit datové struktury objeku, k tomu by si potřeboval třeba digitizer - ručně zadáš data a těmi se naplní objekt. podmínkou serializace je to, že už data v objektu máš k dispozici ... takže zase LinkedList nebo array atd...

4/ mužeš použít i databázi a to NOSQL (https://www.mongodb.com/nosql-explained )  nebo SQL (MS SQL express + MS SQL Server Management Studio). protože máš nesourodá data tak bys musel vytvořit buď více SQL tabulek nebo jednu velkou ale sloupce by jsi pojmenoval s využitím tzv URI (URL,URN) nebo jednoduše GUID identifikátory. asi by ses měl podívat co to je GUID a jak se vytváří a co je to URI a z čeho se skládá. takže název sloupce v SQL tabulce by byl třeba URI:URI:GUID. a v jiné tabulce bys měl seznamu GUID nebo i v té samé to taky de ...

5/ takže teď už chápeš že by ses měl něco doučit ....začal bych se sekvenčním binárním stromem ... uděláš strukturu struct Node { Node* bwLink; Node* FwLink, void* data;} a tu programově vytvoříš cyklem a navážeš ukazatele ... je to v podstatě DoubleLinkedList .... jo jo ....tak to je

pardon správně tam má bejt URI:URN:GUID .... sem se překlep :)

#1 rjulius
Udělal bych to jako strukturu těch 13 struktur. Cykly tím odpadnou, číst/zapisovat můžeš jedním příkazem.

Serializace je samozřejmě lepší kvůli přenositelnosti a snadné editaci.

#13 JerryM
v momentě, kdy tam stejně z jakéhokoliv důvodu musím nacpat SWITCH...CASE jsou mi veškeré veskrze geniální myšlenky a postupy k prdu, jestli mi jako rozumíš :) chápeš jo? :) ale díky

#16 Kit
jo jo, tím by mi odpadlo spoustu starostí. Jenže já to chtěl mít jako oddělené proměnné, protože je v tom akva kontroléru ukládám do flash při změně parametru, nastavení a tak. A nechtěl jsem při každé drobné úpravě... teploty, pH a podobně přepisovat celý blok paměti, protože zápis trvá celkem dlouho. Ne že by to bylo zásadní, ale prostě už to mám takto... Na tu SD kartu jsem to dodělával dodatečně jako zálohu, takže to kvůli tomu nebudu celé předělávat.
nakonec jsem to vyřešil tak, že co jde mám v indexovaném poli (třeba názvy souborů, délky proměnných a podobně) a pouze vlastní zápis proměnné řeším pomocí SWITCH...CASE... čili pokud mi tu někdo radí sice skvělé a moderní metody, ale stejně se SWITCH, nic mi to nepřinese :)

#17 rjulius
Switch-Case přeci mužeš mít v cyklu .. ty to asi nechápeš co ?  ... to nevadí :)

#19 JerryM
ale no tak...  

  switch MyArray[i].Key

    1: {  dynamic_cast<Example_1>(MyArray[i].link*)."proměnná v Example_1"; }

    2: {  dynamic_cast<Example_2>(MyArray[i].link*)."proměnná v Example_2";}

}// for

v podstatě tohle co jsi mi sem dal o kus výše je to samé co tam mám já, akorát že já tam mám 

case PH_METER:
mem.write(pH_meter_address, (uint8_t*)&pH_meter, sizeof(pH_meter));
break;
case THERMO_WATER:
mem.write(Therm_water_address, (uint8_t*)&Therm_water, sizeof(Therm_water));
break;
case THERMO_SPARE:
mem.write(Therm_spare_address, (uint8_t*)&Therm_spare, sizeof(Therm_spare));
 

čili, jo... to že můžu mít switch v cyklu asi trochu chápu... chápeš? :)

hm pokusil sem se to zjednodušit:

 hm pokusil sem se to zjednodušit a nechat tam ten cyklus for:

// CApp.cpp : This file contains the 'main' function. Program execution begins and ends there.
//


#include <iostream>
#include <string>
#include <iterator>
#include <algorithm>
#include <vector>

struct Example_1 {

    int item1;
    float item2;
};

struct Example_2 {
    unsigned long item1;
    int item2;
};


struct arrItem {
    int key;
    void *link;
};


int main()
{

    arrItem *item = nullptr;
    Example_1 *e1 = nullptr;
    Example_2 *e2 = nullptr;

    std::vector<arrItem> DataList; 

    // datovy typ 0 je Example_1
    e1 = new Example_1();
    e1->item1 = 101;
    e1->item2 = (float)102.10;

    DataList.push_back(arrItem());
    DataList[0].key = 0;
    DataList[0].link = e1;

    // datovy typ 1 je Example_2
    e2 = new Example_2();
    e2->item1 = 201;
    e2->item2 = (int)202;

    DataList.push_back(arrItem());
    DataList[1].key = 1;
    DataList[1].link = e2;


    for (int i = 0; i < (int)DataList.size(); i++) {

        switch ((int)DataList[i].key) 
        {
            case 0: 
            {
                Example_1 *ex1 = (Example_1*)DataList[i].link;
                std::cout << "Example_1: key: " << DataList[i].key << "; item1: " << ex1->item1 << "; item2: " << ex1->item2;
                std::cout << "\n";

                break;

            }// case 0: 
            case 1:
            {
                Example_2* ex1 = (Example_2*)DataList[i].link;
                std::cout << "Example_2: key: " << DataList[i].key << "; item1: " << ex1->item1 << "; item2: " << ex1->item2;
                std::cout << "\n";

                break;
            }// case 1: 

        }
        //std::cout << DataList[]

    }// for 


    delete(DataList[0].link);
    DataList[0].link = nullptr;
    delete(DataList[1].link);
    DataList[1].link = nullptr;

    DataList.clear();


}// int main()

#22 JerryM
hezké, ale když já nevidím absolutně žádný přínos krom toho, že bych mohl být na kód možná o trošku pyšnější  :) ale díky :)

samozřejmě pokud chceš naplnit cyklem i ten vector tak v cyklu do něj umístíš 13 struktur arrItem. a samozřejmě je mužeš současně i naplnit např. načtením dat "odněkud"...

for (int i=0; i < 13; i++)
{
   DataList.push_back(arrItem());

   // tady by si to pripadne necim naplnil
   // musis pouzit zase switch pro naplneni
   switch ((int)DataList[DataList.size() - 1].key)
        {
            case 0:
            {
                Example_1 *ex1 = (Example_1*)DataList[DataList.size() - 1].link;
                ex1->item1 =
                ex1->item2 =

                break;

            }// case 0:
            case 1:
            {
                Example_2* ex1 = (Example_2*)DataList[DataList.size() - 1].link;
                ex2->item1 =
                ex2->item2 =

                break;
            }// case 1:

        }

}

njn hele z toho si nic nedělej .. časem se možná naučíš i programovat  a pak už ti to pude samo :)

#23 rjulius
a sakra chybička se vloudila tak ještě jednou :)

#include <iostream>
#include <string>
#include <iterator>
#include <algorithm>
#include <vector>

struct Example_1 {

    int item1;
    float item2;
};

struct Example_2 {
    unsigned long item1;
    int item2;
};


struct arrItem {
    int key;
    void *link;
};


int main()
{

    arrItem *item = nullptr;
    Example_1 *e1 = nullptr;
    Example_2 *e2 = nullptr;

    std::vector<arrItem> DataList; 

    // datovy typ 0 je Example_1
    e1 = new Example_1();
    e1->item1 = 101;
    e1->item2 = (float)102.10;

    DataList.push_back(arrItem());
    DataList[0].key = 0;
    DataList[0].link = e1;

    // datovy typ 1 je Example_2
    e2 = new Example_2();
    e2->item1 = 201;
    e2->item2 = (int)202;

    DataList.push_back(arrItem());
    DataList[1].key = 1;
    DataList[1].link = e2;


    for (int i = 0; i < (int)DataList.size(); i++) {

        switch ((int)DataList[i].key) 
        {
            case 0: 
            {
                Example_1 *ex1 = (Example_1*)DataList[i].link;
                std::cout << "Example_1: key: " 
                          << DataList[i].key 
                          << "; item1: " 
                          << ex1->item1 
                          << "; item2: " 
                          << ex1->item2;
                std::cout << "\n";

                break;

            }// case 0: 
            case 1:
            {
                Example_2* ex2 = (Example_2*)DataList[i].link;
                std::cout << "Example_2: key: " 
                          << DataList[i].key 
                          << "; item1: " 
                          << ex2->item1 
                          << "; item2: " 
                          << ex2->item2;
                std::cout << "\n";

                break;
            }// case 1: 

        }
        //std::cout << DataList[]

    }// for 


    delete(DataList[0].link);
    DataList[0].link = nullptr;
    delete(DataList[1].link);
    DataList[1].link = nullptr;

    DataList.clear();


}// int main()

#25 JerryM

jestli tím myslíš dokazování, že se každá věc dá udělat různými způsoby, přestože žádný z nich není zásadně efektivnější v tom, že se může zcela (v tomto konkrétním případě) vyloučit SWITCH s 13 CASEs... tak jo, to se mám ještě co učit. 
 

Každopádně jádro mého dotazu bylo přesně to, že jsem se snažil vyloučit ten SWITCH pomocí pointerů, kterým nerozumím. Poučil jsem se, jak to s nimi je, což je pro mne přínos. Dále jsem zjistil, že další metody, jakkoli jsou moderní a IN, jsou zbytečným a složitější řešením pro můj konkrétní případ.

Díky za diskuzi :)

jo .. ty asi hledáš něco jako

dynamic_cast<non_static_variable_type*>(object)

kde variable_type je dynamicky volitelný "TYP" ve smyslu class, struct nebo jiný základní typ proměnné ..

hm ... nevim jestli něco takovýho najdeš ... spíš asi ne-e, budeš si muset počkat na standard ANSI C++ v.30

ale mužeš se na to zeptat tady:

https://docs.microsoft.com/en-us/answers/products/

tady máš hezkou odpoveď ohledně vyhození switch:

https://stackoverflow.com/questions/56622499/changing-dynamic-type-of-an-object-in-c

https://www.codeproject.com/Articles/11250/High-Performance-Dynamic-Typing-in-C-using-a-Repla

https://www.geeksforgeeks.org/dynamic-_cast-in-cpp/

#29 JerryM
tak vidíš, už to chápeš :)  no jo no, přesně tak... ze své neznalosti jsem přesně toto hledal, netuše, že je to až tak nesmyslné, že by odborníka ani nenapadlo, že to někdo může hledat :) myšleno bez urážky, samozřejmě.

#31 rjulius
teoreticky je to dobrá věc ... hodila by se spoustě lidem ale zatim to tam ve standardu C++ neni .. v C# je tzv. "aktivátor", kterým můžeš sice vytvořit třídu dynamicky ale i tak musíš použít ten otravnej switch ...

#18 rjulius
Podle mého řešení ten switch ani nepotřebuješ. Pokud zapisuješ do flash, tak stejně přepisuješ celý blok. Smysl by to však dávalo při zápisu do EEPROM, který je pomalý a počítá se každý bajt.

Velmi efektivní a šetrné by však mohlo být žurnálování dat.

#33 Kit
sorry za nepřesnost...je to jednobitová 32 kb EEPROM (AT24C32) , ovládaná přes I2C... líná jako veš

#34 rjulius
V tom případě má smysl, aby každý z těch 13 záznamů měl fixní délku a pevný offset. Seznam těch offsetů by mohl být v poli ve flash s programem. Zapíše se tak vždy jen ta jedna hodnota.

Konstantní délka mu nepomůže. Nejpomalejší je ukládání dat do EEPROM, které proběhne po zapsání dat do vyrovnávacího registru AT24C32. Pokud se dobře pamatuji, je to 10 ms. Samotná komunikace po IIC zase až tak pomalá není, při 50 kb/s je jeden byte asi 180 mikrosekund..Pokud by chtěl zkrátit dobu zápisu dat, měl by se snažit zapsat co nejvíc najednou. Největší časovou ztrátou je zapisování pár Bytů napřeskáčku (v okamžiku, kdy ukončí vysílání, vyvolá zápis a nemůže 10 ms nic dělat, pak zapíše další adresu atd.). A pak zapisování a čtení zbytečných Bytů (musí ten Byte odvysílat, každý zbytečný Byte ho stojí 180 mikrosekund. 100x nic umořilo osla) = zarovnání struktur na konst. délku. Nejrychlejší je tedy sekvenční zápis bloku (všech?) dat. Je to omezeno velikostí vstupního bufferu, jak velký je vstupní buffer si nepamatuju.

K offsetům: výjma sekvenčního čtení/zápisu se vysílá adresa vždy, je tedy úplně jedno, jestli pevný nebo proměnlivý offset, adresování proběhne vždy stejně rychle. Offsety může mít natvrdo nakódované v programu. V podstatě princip, který používá.
 

hu

#36 hlucheucho
To aby si na těch 10 ms natáhl budíka...

Proč to vlastně zapisuje do EEPROM a neponechá v RAM?

#37 Kit
proč to nenechá v RAM... no proč asi, ne? asi protože potřebuje nastavené parametry mít v nějaké non-volatile memory...  

ten zápis neprobíhá často... jen při změně parametrů přes dotykový displej... to u akvárka není tak časté...

ale to už jsme zcela mimo můj původní dotaz...

Proč to vlastně zapisuje do EEPROM a neponechá v RAM?

Protože sebehloupější regulátor si musí pamatovat nastavení i po výpadku napájení. A baterky moc spolehlivé nejsou.

hu

Ještě pozn.: pro ukládání nastavení bych spíš zvolil SPI EEPROM (93C..), protože jsem kůže líná. S SPI je méně práce než s IIC. Ještě lepší je EEPROM přímo na čipu mikrokontroléru.

#38 rjulius
Nějak mi z původního dotazu nevyppllo, že to potřebuješ, aby sis uložil setup.

#40 Kit
no tak jasné, kdybych tady probíral celé řešení s GUI přes dotykové LCD, které ovládá ventil CO2, topení, dvě zářivkové rampy a LED pásky přes DALI protokol s nastavitelným denní průběhem každého světla, měří pH, teploty, hlídá únik vody, průtok filtrem, posílá mailem alarmy přes wifi, budeme tady pět let, protože každý z vás bude mít svůj názor jak řešit jakoukoliv softwarovou nebo hardwarovou část. 
Takže to, že to potřebuju pro uložení setupu do EEPROM a případně vytvoření záloh na SD kartu téhož, nebylo až tak podstatné a ano, neuvedl jsem to... já chtěl jen odbourat ten SWITCH, který měl začal vadit ve spojení s různými struct proměnnými. Nechtěl jsem předělávat celý kód :)

#39 hlucheucho
jj, já jsem taky líný... proto jsem to postavil na platformě ARDUINO DUE a koupil jsem hotový modulek s čipem na real time clock, který na sobě nese zároveň tento čip EEPROM. Flash v procesoru Atmel SAM3X8E ARM Cortex-M3 pro mne má velkou nevýhodu v tom, že je smazána, kdykoliv do něj nahrávám nový kód...což je pro mne nepřijatelné, protože to stále dodělávám a dolaďuji :)  A je to skutečně flash, myslím že má i celkem omezený počet zápisů, ale to by asi nevadilo, to bych asi hned nevyčerpal... ale přeci jen...

hele pupíčku a když tě tak otravuje ten pomalej zápis do tý posraný eeprom tak máš několik možností .. dát si tam rychlejší non-volatile paměť .. nebo si před eeprom dát tzv. komunikační procesor. data pošleš tomu komunikačnímu procesoru maximální rychlostí a on už pak sám od sebe zapíše všechno do tý pomalý eeprom... chápeš jo ? na to ti bude stačit nějak malej jednočip s velkou RAM nebo malej jednočip s velkou externí RAM .... prostě tak něco .. musíš být kreativní ...

a víš o tom že existujou i paměti FRAM ??

https://www.gme.cz/data/attachments/dsh.943-086.1.pdf

protože když si ji koupíš tak nebudeš muset tak "intelektuálně trpět" a my s tebou :) :) :) :)

#44 JerryM
No... Vždyť to říkám, každý je tu génius s miliónem variant řešení, ale jednoduchý dotaz na pointery nevyřeší nikdo. A to jsem si od té diskuze tady tolik sliboval :) 

Nic, všem díky za diskuzi, a zejména těm, pro které odpovědět takové lamě jako jsem já znamenalo hlubokou duševní újmu a snížení se ze svých výšin k zemi. Každopádně to jste mohli řešit i tak, že by jste si táhli po svém a dotazu si nevšímali :)

hm a na co že si se vlastně ptal ? :) :) :) :)
 

Komunikační procesor? Nejdříve bych se podíval na vlastnosti MCU, zda má DMA  Procesor, který pracuje s dotykovým displejem asi bude něco výkonnějšího a schopnějšího a tak ho asi mít bude (díval jsem se, SAM3X8E má DMA).

Pokud rjulius pro komunikaci s IIC řadič DMA nepoužil, má to jako námět k dalšímu studiu a vylepšení.

Navzdory tomu bude muset neustále brát v úvahu, že po zápisu je EEPROM nějakou dobu nečinná.

Použil hotový hardware, odpadla mu práce s jeho návrhem. Navíc ho získal za malou část nákladů za které by ho sám navrhl a vyrobil. Má to i nevýhodu - nemá na desce nač si vzpomene, dobastlit to stojí další peníze a čas a v tomto případě přibastlení jakékoliv paměti bude znamenat vynaložené náklady bez valného přínosu. Takže se přikláním k maximálnímu využití hardware, který je k dispozici.

hu

#47 hlucheucho
jj, přesně. navíc pro tyhle hardwarové kousky samozřejmě využívám podpory existujících knihoven, které ve víceméně funkční podobě existují i pro tak okrajové věci jako je DALI protokol pro řízení světel. Takže ano, je to amatérský hobby bastl za zlomek nákladů proti profi řešení, obzvlášť kdyby profi řešení měla být kusovka. I ten displej je hotový modul s paralelním připojením přes datové piny, pro které bohužel DMA využít nelze. Prostě přesně jak píšeš... má to spoustu nevýhod vyvážených tím, že si to v pohodě na koleně dokážu namontovat do krabice z 3D tiskárny za zanedbatelné náklady, splňuje to účel a já z toho mám radost. A že v C++ plavu, s tím jsem smířený, ale vytyčený cíl jsem proplaval :)

Roman

#45 rjulius
Vždyť to říkám, každý je tu génius s miliónem variant řešení, ale jednoduchý dotaz na pointery nevyřeší nikdo.

Pointer skutečně je jen adresa, to jsi věděl. A můžeš ho libovolně přetypovat, to ses dozvěděl hned na začátku. JerryM tak nějak ze zásady nikdy netuší o čem je řeč a můžeš ho ignorovat, ostatní komentáře mi připadají přínosné.

#49 gna
To co cituješ, to už byla jen nadsázka, to nebyla urážka, byl tam smajlík.... To jen aby bylo jasno. 

Ano, pro mne to přínosné bylo.

přestaň mě ignorovat !!! okamžitě :)  :)  :)  :)  nařizuju ti to :)  :)  :)

pochopte že

static_cast< decltype(DataList[i].ex1) > ( DataList[i].link )->item1

ničemu nepomuže i když budu mít:

struct arrItem {

    int key;
    void *link;

    Example_1* ex1;
    Example_2* ex2;
};

a stejně tak se nedá použít ani type_info

https://en.cppreference.com/w/cpp/header/typeinfo

to je jak mluvit do dubu

sakra 21:00 ... večerka .. musim jít spát

Ja#51 JerryM
Já už to tu asi zamknu, ne? Když už stejně musíš na pokoj....

tady si to přečtěte ať víme všichni o co de

https://www.stroustrup.com/multimethods.pdf

sakra 21:01  ... musim zhasnout

Zamykám vlákno, nic nového už to tu asi nepřinese a JerryM je zpátky v cele...