Minha abordagem. O núcleo é o motor. - página 6

Novo comentário
 
Peter, você tem a OLP como um trapo vermelho na frente do olho de um touro. Nenhum outro tópico discute tanto o OOP quanto você. E isto apesar do fato de você não ter escrito um único programa neste mesmo OOP. Você não acha tudo isso estranho?
 
Vasiliy Sokolov:
Peter, você tem OOP como um trapo vermelho na frente do olho de um touro. Nenhum outro tópico discute tanto o OOP quanto você. E tudo isso apesar do fato de não ter escrito um único programa neste mesmo OOP. Você não acha tudo isso estranho?

Estou simplesmente respondendo a sugestões para usar o OOP dentro da minha abordagem. Estas abordagens não são compatíveis.

Portanto, continuarei a explicar minha abordagem, sem explicar porque não uso a sintaxe OOP dentro dela.


Se eu não o usar, então não há necessidade de fazê-lo.

 
Dmitry Fedoseev:

Ambas as teses são falsas.

Não arraste o iniciador do tópico aqui por 6 páginas já, mas não está claro o que ele quer mostrar, está claro que é tudo sobre o kernel ))))

ele nos mostrará um exemplo e então o convenceremos de que o OOP economiza tempo no desenvolvimento de software ;)

 
Seis páginas de nada. Para os comerciantes, o principal é ter lucro. :) Se o código tem ou não OOP é de importância secundária.
 
Реter Konow:

Se eu não o uso, então não há necessidade de usá-lo.

Se você não entender algo, nunca poderá haver a necessidade de utilizá-lo. Portanto, o que quer que tenha acontecido em suas mega-library, "não será necessário" para o OOP.

 
Vasiliy Sokolov:

Se você não entender algo, nunca poderá haver a necessidade de usá-lo. Portanto, o que quer que você tenha em suas mega-library, não há "nenhuma necessidade" de OOP lá.

 

Então, vamos começar com uma fácil. Vamos criar um elemento protótipo dentro do proto-kernel:

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 свойств.
 

E assim, o elemento é representado no proto-core em forma de tabela expandida.

A representação tabular tem suas vantagens. Principalmente em loops.


Vamos agora escrever uma função que irá criar um item.

Mas primeiro, vamos definir as propriedades do item via definições, para que seja fácil consultá-las.

  
#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]
 

Escrevemos uma função que irá criar um botão:

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); 
}


É claro, alguns dirão que o núcleo é desnecessário. Uma chamada como esta será suficiente:

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

e tudo será o mesmo. Sim, mas somente no início. O problema com tal chamada é que ela não pode ser devidamente desenvolvida.


Precisamos que as propriedades de cada elemento sejam ordenadas na memória global e acessíveis da maneira mais simples.

12345678910111213...184
Novo comentário