Discussion of article "LifeHack for traders: Blending ForEach with defines (#define)" - page 6

New comment
 

How do you imagine an article?! I take my source code from KB and start to describe in the article why I decided to apply a macro in this place and why it is exactly like this?

For each work in KB there is a discussion thread. There you can ask questions about the sources.

 
fxsaber:

How do you imagine an article?! I take my source code from KB and start to describe in the article why I decided to apply a macro in this place and why it is exactly like this?

For each work in KB there is a discussion thread. There you can ask questions about sources.

For example, here I do not beat off hollows at all).

#define  MT4_ORDERFUNCTION(NAME,T,A,B,C)                               \
  static T MT4Order##NAME( void )                                     \
  {                                                                   \
    return(POSITION_ORDER((T)(A), (T)(B), MT4ORDERS::Order.NAME, C)); \
  }

It would not be bad to describe these things!

 
Vitaly Muzichenko:

For example, here's where I don't hollow out at all)

It would be nice to describe these things!

This is a multi-line macro with five input parameters. Look at the text, with which parameters it is called.

It creates corresponding methods named MT4OrderTicket, MT4OrderClosePrice, etc. The methods are 95% identical in text and there are many of them. In order not to make a huge copypaste, where an error can easily creep in, a macro is made. Everything is compact and immediately visible.

Moreover, this code emphasises that the functions are 95% the same. That is, when reading it, you realise it at once. But if you were to write classically, you could make such a conclusion only by reading and analysing the code of 20 methods (there are so many of them). And this is a big headache. And so all 20 methods are on one screen and everything is emphasised that the methods almost coincide. And only the input parameters of macros tell about the differences. You pay attention to these differences and not to the tinsel when reading. I.e. the code shows the main thing at once - the core and not a mundane shell.

 
Vasiliy Sokolov:

The things he's doing are out of the box. That's valuable knowledge that should be shared with the public!

Well, he is sharing it. Some of his posts and descriptions of code in KB are more informative than half of the articles here.

I also don't understand why there is an artificial reference book, if there are live answers from him to all the questions asked.

It would be better if Renat would get rid of his habit of banning him for every harsh statement.

 

Would the developer make an additional command "make a copy of the file, replace macros without compilation and open the file" to the "Compile" button in the editor. Especially for studying macros from fxsaber.

Or you can use the command in the context menu. Put the mouse on the macro call, select the command, the code obtained after macro replacement is copied to the buffer.

 

In general, macros can be understood like this:

1. It is necessary to separate the macro name from its value. First in the line goes #define, then a space, after it this name (it can be with parameters), then another space or transition to a new line and the value of the macro.

2. We see how the macro is called in the code, what its parameters are. Make a copy of the macro value and replace the parameters with those parameters with which it is called somewhere in the code.

3. Where the macro is called in the code, replace it with what we got in step 2.

Approximately like this.

There are some things you need to know: \ - it means continuation on a new line. ## - it is a connection of lines.
 
The most frequently used by me macro

Forum on trading, automated trading systems and testing trading strategies

Features of mql5 language, subtleties and techniques of work

fxsaber, 2017.12.05 11:39 pm.

In debug mode, you can't find out the value that a function or expression returns.

For example

void OnStart()
{
  double Angle = 1;
  double d = MathSin(Angle / 2) * MathSin(Angle * 2);
}

For example, what the highlighted functions returned.


I use (not only in debug mode) this way

template <typename T>
T MyPrint( const T Value, const string Str )
{
  static const bool IsDebug = MQLInfoInteger(MQL_DEBUG);

// if (IsDebug)
  {
// DebugBreak(); // if you want to see by debug means

    Print(Str + " = " + (string)Value);
  }
  
  return(Value);
}

#define _P(A) MyPrint(A, __FUNCSIG__ ", Line = " + (string)__LINE__ + ": " + #A)

void OnStart()
{
  double Angle = 1;
  double d = _P(MathSin(Angle / 2)) * _P(MathSin(Angle * 2));
}


Result

void OnStart(), Line = 21: MathSin(Angle/2) = 0.479425538604203
void OnStart(), Line = 21: MathSin(Angle*2) = 0.9092974268256817

I have formatted it as mqh.

Cross-platform script as an example

#include <MT4Orders.mqh>

#define Ask SymbolInfoDouble(_Symbol, SYMBOL_ASK)

void OnStart()
{
  // Opens and closes a BUY position
  if (OrderSelect(OrderSend(_Symbol, OP_BUY, 1, Ask, 100, 0, 0), SELECT_BY_TICKET))
    OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), 100);
}


Let's say we wanted to know what OrderClosePrice() returns in this code. Let's do it like this

OrderClose(OrderTicket(), OrderLots(), _P(OrderClosePrice()), 100);


And here is the code if you want to know almost everything (it happens when you don't understand at all where the problem is in your own or someone else's code).

#include <MT4Orders.mqh>

#define Ask SymbolInfoDouble(_Symbol, SYMBOL_ASK)

#include <Debug.mqh> // https://c.mql5.com/3/173/Debug.mqh

void OnStart()
{
  // Opens and closes a BUY position
  if (_P(OrderSelect(_P(OrderSend(_P(_Symbol), _P(OP_BUY), 1, _P(Ask), 100, 0, 0)), _P(SELECT_BY_TICKET))))
    _P(OrderClose(_P(OrderTicket()), _P(OrderLots()), _P(OrderClosePrice()), 100));
}

I.e. any place whose value you want to see, we put it into _P(). The result

void OnStart(), Line = 10: SELECT_BY_TICKET = 1
void OnStart(), Line = 10: Ask = 1.16688
void OnStart(), Line = 10: OP_BUY = 0
void OnStart(), Line = 10: _Symbol = EURUSD
void OnStart(), Line = 10: OrderSend(_P(_Symbol),_P(OP_BUY),1,_P(Ask),100,0,0) = 293785198
void OnStart(), Line = 10: OrderSelect(_P(OrderSend(_P(_Symbol),_P(OP_BUY),1,_P(Ask),100,0,0)),_P(SELECT_BY_TICKET)) = true
void OnStart(), Line = 11: OrderClosePrice() = 1.16678
void OnStart(), Line = 11: OrderLots() = 1.0
void OnStart(), Line = 11: OrderTicket() = 293785198
void OnStart(), Line = 11: OrderClose(_P(OrderTicket()),_P(OrderLots()),_P(OrderClosePrice()),100) = true


Or, for example, there is such an expression

void OnStart()
{
  int a = 137;
  double b = 1.37;
  
  int Num = ((a = (int)(a / b)) << 1) * a; // 19602
}

We need to quickly figure out why 19602 is output. We put the pieces we want to quickly find out into our macro

int Num = _P(_P(((a = _P((int)(_P(a / b)))) << 1)) * _P(a));


And we can see the result of the calculation step by step

void OnStart(), Line = 8: a/b = 99.99999999999999
void OnStart(), Line = 8: (int)(_P(a/b)) = 99
void OnStart(), Line = 8: ((a=_P((int)(_P(a/b))))<<1) = 198
void OnStart(), Line = 8: a = 99
void OnStart(), Line = 8: _P(((a=_P((int)(_P(a/b))))<<1))*_P(a) = 19602


ZY Instead of a piece of article...

  
#define ForEachSymbol(s,i)  string s=SymbolName(0,true); int os_total=SymbolsTotal(true); for(int i=1;i<os_total;i++,s=SymbolName(i,true))

There is a bug, first symbol process is with position_index 0, next one is with position_index 2. You are missing position_index 1 and your loop is executed only os_total-1 times.

#define ForEachOrder(ticket,i)    HistorySelect(0,TimeCurrent());  ulong ticket=OrderGetTicket(0); int or_total=OrdersTotal();   for(int i=1;i<or_total;i++,ticket=OrderGetTicket(i))
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   ForEachOrder(orderticket,index)
     {
      Print(index,": #",orderticket," ",OrderGetString(ORDER_SYMBOL)," ",
            EnumToString((ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE)));
     }
/* Sample output     
   1: 13965457  CADJPY ORDER_TYPE_SELL_LIMIT
   2: 14246567  AUDNZD ORDER_TYPE_SELL_LIMIT
*/ 
  }

In this one there is the same bug as previously.

And additionally you are mixing functions to work on open orders and history selection. If your intend was to work with open orders, there is no need to use HistorySelect().

By the way these bugs demonstrate well the problem with without macro. It's hard or impossible to debug.

The most strongest criticism of using #define is the fact that macro substitutions do not allow for code debugging. I agree with this, although, as fxsaber says, "A reliably fixed patient requires no anesthesia debugged macro requires no debugging".

I stopped reading after that, sorry.

 
MetaQuotes:

New article LifeHack for traders: Blending ForEach with defines (#define) has been published:

Author: Vladimir Karputov

maybe you considered to add 2 more defines for mql4, OrderCalcProfit() and OrderCalcMargin()
 
daengrani #:
maybe you considered to add 2 more defines for mql4, OrderCalcProfit() and OrderCalcMargin()
No.  The old terminal has not been supported for a long time.
1234567
New comment