Il mio approccio. Il nucleo è il motore. - pagina 7

Nuovo commento
 
Il modo migliore per organizzare proprietà, oggetti ed elementi è quello di creare una tabella.

Il nucleo degli elementi è la tavola.

Abbiamo creato un modello proto-kernel, progettato per memorizzare i parametri iniziali dell'oggetto di un particolare elemento.

Successivamente, dobbiamo creare un Kernel principale e scrivere tutti gli elementi di cui abbiamo bisogno in esso.

Poi, imposteremo nuovi valori ad ogni elemento all'interno del kernel principale.

Dopo di che creeremo degli elementi.

Poi lavoreremo con loro in diversi eventi.


 

Dichiarare il nucleo principale:

int G_CORE[All_objects][All_properties];

Ogni riga del Nucleo occuperà un Oggetto.

Dobbiamo determinare quanti oggetti totali ci saranno nel nucleo. Per fare questo, dobbiamo calcolare il numero di Oggetti che vogliamo creare e il numero di Oggetti in ogni Oggetto.

Diciamo che abbiamo 10 pulsanti. Quindi: 10 elementi * 3 oggetti = 30 oggetti. Quindi ci sono 30 file.

#define  All_objects     30
#define  All_properties  10

Abbiamo aumentato il numero di proprietà nel nucleo principale, perché oltre ai parametri di base abbiamo bisogno dei nomi degli elementi e degli oggetti, dei collegamenti tra loro e di alcune altre proprietà.


Ridichiariamo le proprietà degli oggetti:

#define  NAME        0
#define  TYPE        1
#define  ELEMENT     2

#define  X           3
#define  X_SIZE      4
#define  Y           5
#define  Y_SIZE      6
#define  BG_COLOR    7
#define  TEXT_COLOR  7
#define  TEXT        8
#define  CORNER      9
#define  STATE       10
//-------------------

La proprietà TEXT conterrà un riferimento ad un altro array che conterrà i testi dei pulsanti.

La proprietà ELEMENT è necessaria per collegare oggetti dello stesso elemento all'interno del nucleo (per evitare confusione su quale oggetto appartiene a quale elemento). In questa proprietà imposteremo il numero di sequenza dell'elemento.

 
Реter Konow: /Questo è l'aspetto delle chiamate alle proprietà degli elementi:

È molto facile confondere base, testo e icona. È chiaro nella descrizione cosa c'è dentro questo o quell'indice. Nella programmazione reale, devi tenere tutto nella tua testa. So che Peter è un titano della memoria con una capacità di dimenticare fortemente compromessa. Ma temo che non ci siano molti titani del genere. Sto già dimenticando dove e cosa mettere il giorno dopo.

Non sarebbe meglio avere più o meno quanto segue (io farei così):

Dichiarare le strutture elementari di cui abbiamo bisogno.

struct SPosition
{
uint m_uiX;
uint m_uiY;
};

struct SElementSize
{
uint m_uiXSize;
uint m_uiYSize;
};

Ora possiamo ottenere le interfacce base, testo e icona dall'oggetto comune:

CBaseI* pbBase = core.GetBase();
CTextI* ptText = core.GetText();
CIconI* pbIcon = core.GetIcon();

E una qualsiasi di queste tre interfacce - imposta la proprietà appropriata. Beh, per esempio, il testo:

ptText.SetPosition(SPosition& rpPos);

Riempiamo la struttura di posizione (X e Y), chiamiamo l'interfaccia di testo dal nucleo, e da questa interfaccia chiamiamo la funzione di impostazione della posizione con la nostra struttura. Ognuna di queste interfacce ha anche una funzione per impostare le dimensioni e il colore. Ha senso ereditarle da un'interfaccia comune puramente virtuale, dove tutte le funzioni sono impostate su zero.

Qui è molto più difficile mescolare le cose. Perché in ogni momento hai accesso solo a quello che ti serve per fare il tuo lavoro. E per qualcos'altro, devi chiamarlo, e se non ti è permesso farlo, allora con una corretta progettazione del sistema non puoi nemmeno chiamare questa interfaccia "proibita", proteggendoti così dagli errori.

 

E così, cambiamo prima il numero di proprietà del kernel prototipo, erano le stesse del kernel principale. Poi facciamo un ciclo di costruzione di G_CORE.

int P_CORE[3][10] = {
//Основание кнопки.-----------------------------
//
//NAME     TYPE   ELEMENT     X    Y     X_SIZE  Y_SIZE       COLOR 
//----------------------------------------------
{ 100001,  base,  button,    100, 100,    200,    50,    C'245,245,245'},
//---------------------------------------------- 
//Текст кнопки.---------------------------------
//
//NAME    TYPE   ELEMENT   X    Y     X_SIZE  Y_SIZE       COLOR 
//----------------------------------------------
{100002,  text,  button,  120, 120,     0,      0,       C'245,0,0'},
//---------------------------------------------- 
//Иконка кнопки.-------------------------------- 
//
//NAME    TYPE     ELEMENT   X    Y     X_SIZE  Y_SIZE       COLOR 
{100003,  icon,    button,  140, 140,     16,     16,           0},
//---------------------------------------------- 
};
//Далее, строим G_CORE:
//--------------------------------------
int q = 0;
//--------------
for(int a1 = 0; a1 < All_objects; a1++)
  {
   for(int a2 = 0; a2 < All_properties; a2++)
    {
     G_CORE[a1][a2] = P_CORE[q][a2];
    }
     q++;
     if(q == 3)q = 0;    
  }


Dopo questo ciclo il nucleo G_CORE sarà riempito di prototipi di 10 pulsanti. Successivamente, il nostro compito è quello di dare agli elementi nomi unici e legare gli oggetti ai loro elementi, dando ad ogni elemento un indice unico.

 
Реter Konow:

E così, cambiamo prima il numero di proprietà del kernel prototipo, erano le stesse del kernel principale. Poi facciamo un ciclo per costruire G_CORE.

Potete vederlo perfettamente da questo codice.

Ho già dimenticato cosa significa a1 e cosa significa a2.

Ma è metà del problema - se l'ho dimenticato, dovrò guardare sopra. Ma posso essere sicuro di non aver dimenticato, e posso ancora mescolare gli elementi. E poi è buono, se viene bene. Altrimenti non è affatto un fatto, e l'errore può verificarsi molto più tardi, e colpirà, per la legge della sfortuna, nel luogo più vulnerabile, e nel momento più inopportuno.

L'approccio di Peter è quello di un titano della memorizzazione, che è anche abbastanza normale. Ma quanti partecipanti sono tali titani?

 

Nel frattempo, anche alcuni una piccola azienda ha aperto il codice della sua GUI sfigata :-)

stanno davvero facendo il giro del mondo...hanno paura della concorrenza!!!

scherzi, scherzi, ma chiunque sia interessato può vedere come la GUI di Windows è costruita dall'interno:

WPF è un framework UI .NET Core per costruire applicazioni desktop per Windows. https://github. com/dotnet/wpf

Windows Forms è un framework UI di .NET Core per costruire applicazioni desktop di Windows: https://github.com/dotnet/winforms

Versioni retrocompatibili delle caratteristiche di Windows UI, compresi i controlli UWP XAML e gli stili e materiali Fluent: https://github.com/Microsoft/microsoft-ui-xaml


 
Maxim Kuznetsov:

Nel frattempo, anche alcuni una piccola azienda ha aperto il codice della sua scadente GUI :-

La GUI non è il problema qui. Il mio approccio può essere estrapolato e applicato a qualsiasi scopo. Compresa l'IA.

Poi vi mostrerò come si può fare.

 
George, per favore lasciami continuare. So che preferite l'OOP e che vi sentite più a vostro agio così. Ma le vostre decisioni sono calcolate sulla base delle credenziali di un programmatore. Ora sto cercando un approccio, attraverso il quale si può raggiungere il massimo sviluppo. La convenienza viene al secondo posto.
 
Реter Konow:

Dobbiamo determinare quanti oggetti ci saranno nel nucleo. Per fare questo, dobbiamo calcolare il numero di Oggetti che vogliamo creare e il numero di Oggetti in ogni Oggetto.

#define  All_objects     30
#define  All_properties  10

Domanda dal pubblico:

Supponiamo di creare una tabella di accordi del trading Expert Advisor. Ogni riga - una transazione con l'entrata, il prezzo di uscita, il volume, ecc. Come sapere in anticipo, prima di compilare, il numero di trade che l'Expert Advisor eseguirà per determinare correttamente il numero di righe della tabella?

 
Vasiliy Sokolov:

Domanda dal pubblico:

Supponiamo di creare una tabella di trade di un Expert Advisor di trading. Ogni riga è un trade con l'entrata, il prezzo di uscita, il volume, ecc. Come posso sapere in anticipo, prima della compilazione, il numero di operazioni che l'Expert Advisor eseguirà, per determinare correttamente il numero di righe nella tabella?

Aggiungere un numero all'array usando ArrayResize su ogni transazione, e registrare le proprietà dell'affare in esso.

Allo stesso tempo, le proprietà saranno distribuite in anticipo tra le celle.

In seguito, tutti i dati saranno ordinati.

1234567891011121314...184
Nuovo commento
Motivazione: