Mon approche. Le noyau est le moteur. - page 6

Nouveau commentaire
 
Peter, vous avez l'OLP comme un chiffon rouge devant un œil de taureau. Aucun autre fil de discussion ne traite de la POO autant que vous le faites. Et ce malgré le fait que vous n'ayez pas écrit un seul programme dans cette même POO. Vous ne trouvez pas tout cela étrange ?
 
Vasiliy Sokolov:
Peter, vous avez OOP comme un chiffon rouge devant un œil de taureau. Aucun autre fil de discussion ne traite de la POO autant que vous le faites. Et tout cela en dépit du fait que vous n'avez pas écrit un seul programme dans cette même POO. Vous ne trouvez pas tout cela étrange ?

Je réponds simplement aux suggestions d 'utiliser la POO dans mon approche. Ces approches ne sont pas compatibles.

Je vais donc continuer à expliquer mon approche, sans expliquer pourquoi je n'utilise pas la syntaxe de la POO dans celle-ci.


Si je ne l'utilise pas, ce n'est pas la peine.

 
Dmitry Fedoseev:

Les deux thèses sont fausses.

Ne traînez pas le topicstarter ici depuis 6 pages déjà, mais ce n'est pas clair ce qu'il veut montrer, c'est clair qu'il s'agit du noyau )))).

il nous montrera un exemple et nous le convaincrons alors que la POO permet de gagner du temps dans le développement de logiciels ;)

 
Six pages de rien. Pour les traders, l'essentiel est de faire des bénéfices. :) Que le code soit OOP ou non est d'une importance secondaire.
 
Реter Konow:

Si je ne l'utilise pas, alors il n'y a pas besoin de l'utiliser.

Si vous ne comprenez pas quelque chose, vous n'aurez jamais besoin de l'utiliser. Donc, peu importe ce que vous avez dans vos méga-bibliothèques, ce ne sera "pas nécessaire" pour la POO.

 
Vasiliy Sokolov:

Si vous ne comprenez pas quelque chose, vous n'aurez jamais besoin de l'utiliser. Donc, peu importe ce que vous avez dans vos méga-bibliothèques, il n'y a "aucun besoin" de POE là.

 

Alors, commençons par une facile. Créons un élément prototype à l'intérieur du proto-noyau :

int P_CORE[3][5] = {
//Основание кнопки.-----------------------------
//
//  X    Y     X_SIZE  Y_SIZE       COLOR 
//----------------------------------------------
{  100, 100,    200,    50,    C'245,245,245'},
//---------------------------------------------- 
//Текст кнопки.---------------------------------
//
//  X    Y     X_SIZE  Y_SIZE       COLOR 
//----------------------------------------------
{  120, 120,     0,      0,       C'245,0,0'},
//---------------------------------------------- 
//Иконка кнопки.-------------------------------- 
//
//  X    Y     X_SIZE  Y_SIZE       COLOR 
{  140, 140,     16,     16,           0},
//---------------------------------------------- 
};


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

Элемент кнопка состоит из 3-ех объектов. Каждому из них мы предоставили 5 свойств.
 

Ainsi, l'élément est représenté dans le proto-core sous forme étendue et tabulaire.

La représentation tabulaire a ses avantages. Principalement dans les boucles.


Écrivons maintenant une fonction qui va créer un élément.

Mais d'abord, définissons les propriétés de l'élément par le biais de définitions, afin qu'il soit facile de s'y référer.

  
#define  BASE        0
#define  TEXT        1
#define  ICON        2
//-------------------
#define  X           0
#define  X_SIZE      1
#define  Y           2
#define  Y_SIZE      3
#define  BG_COLOR    4
#define  TEXT_COLOR  4
//-------------------
//Вот как будут выглядеть обращения к свойствам элемента:

P_CORE[BASE][X]
P_CORE[BASE][Y]
P_CORE[BASE][X_SIZE]
P_CORE[BASE][Y_SIZE]
P_CORE[BASE][COLOR]

P_CORE[TEXT][X]
P_CORE[TEXT][Y]
P_CORE[TEXT][X_SIZE]
P_CORE[TEXT][Y_SIZE]
P_CORE[TEXT][COLOR]

P_CORE[ICON][X]
P_CORE[ICON][Y]
P_CORE[ICON][X_SIZE]
P_CORE[ICON][Y_SIZE]
P_CORE[ICON][COLOR]
 

Nous écrivons une fonction qui va créer un bouton :

void Create_element(string name, string Text)
{
 ObjectCreate(0,name,OBJ_BUTTON,0,0,0);
 ObjectSetInteger(0,name,OBJPROP_XDISTANCE,P_CORE[BASE][X]);
 ObjectSetInteger(0,name,OBJPROP_YDISTANCE,P_CORE[BASE][Y]);
 ObjectSetInteger(0,name,OBJPROP_XSIZE,P_CORE[BASE][X_SIZE]);
 ObjectSetInteger(0,name,OBJPROP_YSIZE,P_CORE[BASE][Y_SIZE]);
 ObjectSetString(0,name,OBJPROP_TEXT,Text);
 //----------------------------------------------
 ObjectSetInteger(0,name,OBJPROP_BGCOLOR,P_CORE[BASE][BG_COLOR]));
 ObjectSetInteger(0,name,OBJPROP_COLOR,P_CORE[TEXT][TEXT_COLOR])); 
 //----------------------------------------------
 ObjectSetInteger(0,name,OBJPROP_CORNER,CORNER_LEFT_UPPER);
 ObjectSetInteger(0,name,OBJPROP_ANCHOR,ANCHOR_LEFT_UPPER); 
}


Bien sûr, certains diront que le noyau est inutile. Un appel comme celui-ci suffira :

Create_element(name,x,y,x_size,y_size,text,anchor,corner...)

et tout sera comme avant. Oui, mais seulement au début. Le problème d'un tel appel est qu'il ne peut être développé correctement.


Nous avons besoin que les propriétés de chaque élément soient organisées dans la mémoire globale et accessibles de la manière la plus simple.

12345678910111213...184
Nouveau commentaire