Mein Ansatz. Der Kern ist der Motor. - Seite 6

Neuer Kommentar
 
Peter, Sie haben die PLO wie ein rotes Tuch vor einer Zielscheibe. In keinem anderen Thread wird so viel über OOP diskutiert wie in diesem. Und das, obwohl Sie nicht ein einziges Programm in eben dieser OOP geschrieben haben. Finden Sie das alles nicht seltsam?
 
Vasiliy Sokolov:
Peter, du hast OOP wie ein rotes Tuch vor einer Zielscheibe. In keinem anderen Thread wird so viel über OOP diskutiert wie in diesem. Und das alles, obwohl Sie kein einziges Programm in eben dieser OOP geschrieben haben. Finden Sie das alles nicht seltsam?

Ich reagiere lediglich auf Vorschläge , OOP in meinem Ansatz zu verwenden. Diese Ansätze sind nicht miteinander vereinbar.

Ich werde also meinen Ansatz erläutern, ohne zu erklären, warum ich darin keine OOP-Syntax verwende.


Wenn ich es nicht benutze, dann ist es auch nicht nötig.

 
Dmitry Fedoseev:

Beide Thesen sind falsch.

Ziehen Sie den Themenstarter hier nicht schon 6 Seiten lang, aber es ist nicht klar, was er zeigen will, es ist klar, dass es um den Kernel geht ))))

er wird uns ein Beispiel zeigen und dann werden wir ihn davon überzeugen, dass OOP bei der Softwareentwicklung Zeit spart ;)

 
Sechs Seiten mit nichts. Für Händler geht es in erster Linie darum, einen Gewinn zu erzielen. :) Ob der Code OOP hat oder nicht, ist zweitrangig.
 
Реter Konow:

Wenn ich es nicht benutze, gibt es auch keinen Grund, es zu benutzen.

Wenn man etwas nicht versteht, kann man es nicht gebrauchen. Was auch immer Sie also in Ihren Mega-Bibliotheken vorhaben, es wird für OOP "nicht notwendig" sein.

 
Vasiliy Sokolov:

Wenn man etwas nicht versteht, kann man es nicht gebrauchen. Was auch immer Sie also in Ihren Mega-Bibliotheken haben, es besteht dort "keine Notwendigkeit" für OOP.

 

Beginnen wir also mit einer einfachen Frage. Erstellen wir ein Prototyp-Element innerhalb des Proto-Kerns:

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

Das Element wird also im Proto-Kern in erweiterter, tabellarischer Form dargestellt.

Die tabellarische Darstellung hat ihre Vorteile. Vor allem in Schleifen.


Schreiben wir nun eine Funktion, mit der ein Element erstellt wird.

Doch zunächst sollten wir die Eigenschaften des Objekts über Defines definieren, damit man sich leicht auf sie beziehen kann.

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

Wir schreiben eine Funktion, die eine Schaltfläche erstellt:

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


Natürlich werden einige sagen, dass der Kernel unnötig ist. Ein Anruf wie dieser reicht aus:

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

und alles wird wie früher sein. Ja, aber nur am Anfang. Das Problem bei einem solchen Aufruf ist, dass er nicht richtig entwickelt werden kann.


Die Eigenschaften der einzelnen Elemente müssen im globalen Speicher organisiert und auf einfachste Weise zugänglich sein.

12345678910111213...184
Neuer Kommentar