Как Вы определили бы простой “минимальный” метод в obj-c

Лично я использую первый стиль только для преждевременного создания исключения или возврата из метода. Как аргумент Проверка в начале функции, потому что в этих случаях, редко у меня есть более чем одно дело, и нет никогда больше.

Пример:

if (argument == null)
    throw new ArgumentNullException("argument");

if (argument < 0)
    return false;

В противном случае я использую второй стиль.

Я предпочитаю использовать скобки. Добавление фигурных скобок упрощает чтение и изменение.

Вот некоторые ссылки для использования фигурных скобок:

• Предпочитайте многострочные, если

• Пропускающие фигурные скобки: не только вопрос стиля

• Переполнение стека

Методы класса Objective-C используют именованные параметры, период. Это всего лишь путь.

Почему бы не сделать ее глобальной, свободной функцией? Тебе не нужен класс Utils для такого рода вещей.

Если не нужно загромождать глобальное пространство имен, можно использовать Objective-C + + (переименовать все файлы .m в .mm) и поместить его в пространство имен.

уже определяется как макрос.

MIN(a, b)

MAX(a, b)

Вам не нужно переопределить эти.

Возможно, это не очень хорошая идея для данного конкретного приложения, но возможно писать методы Objective-C с параметрами "без имен", или, скорее, с именами нулевой длины:

+ min:(int)a :(int)b;
...
[Utils min:a :b]

(Селектор будет @selector(min::))

Существует серьезная проблема с решением, опубликованным Брэндоном Боднаром (которое на момент написания этой статьи помечено как действительное).

Проблема описана здесь: http://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Min-and-Max.html И (действительное и безопасное) решение для него: http://gcc.gnu.org/onlinedocs/gcc-3.4.6/gcc/Typeof.html

Проверьте сами:

#include <stdio.h>

#define NAIVE_MAX(a,b) (a > b ? a : b)

#define NAIVE_MIN(a,b) (a < b ? a : b)

#if !defined MAX
#define MAX(a,b) \
({ __typeof__ (a) __a = (a); \
__typeof__ (b) __b = (b); \
__a > __b ? __a : __b; })
#endif

#if !defined MIN
#define MIN(a,b) \
({ __typeof__ (a) __a = (a); \
__typeof__ (b) __b = (b); \
__a < __b ? __a : __b; })
#endif

int main (int argc, const char * argv[]) {
    int a = 3;
    int b = 5;

#pragma mark NON-FATAL CASES:
    printf("NAIVE_MAX(%d, %d) => %d\n", a, b, NAIVE_MAX(a, b));
    printf("NAIVE_MIN(%d, %d) => %d\n", a, b, NAIVE_MIN(a, b));

    printf("MAX(%d, %d) => %d\n", a, b, MAX(a, b));
    printf("MIN(%d, %d) => %d\n", a, b, MIN(a, b));

    printf("\nEverything fine so far...\n\n");

#pragma mark FATAL CASES:
    //cache:
    int _a = a;
    int _b = b;
    printf("NAIVE_MAX(%d++, %d++) => %d\n", _a, _b, NAIVE_MAX(a++, b++));

    //reset:
    a = _a;
    b = _b;
    printf("NAIVE_MIN(%d++, %d++) => %d\n", _a, _b, NAIVE_MIN(a++, b++));

    //reset:
    a = _a;
    b = _b;
    printf("NAIVE_MAX(++%d, ++%d) => %d\n", _a, _b, NAIVE_MAX(++a, ++b));

    //reset:
    a = _a;
    b = _b;
    printf("NAIVE_MIN(++%d, ++%d) => %d\n", _a, _b, NAIVE_MIN(++a, ++b));

    printf("\nOuch, this doesn't look right at all!\n\n");

#pragma mark NON-FATAL CASES:
    //reset:
    a = _a;
    b = _b;
    printf("MAX(%d++, %d++) => %d\n", _a, _b, MAX(a++, b++));

    //reset:
    a = _a;
    b = _b;
    printf("MIN(%d++, %d++) => %d\n", _a, _b, MIN(a++, b++));

    //reset:
    a = _a;
    b = _b;
    printf("MAX(++%d, ++%d) => %d\n", _a, _b, MAX(++a, ++b));

    //reset:
    a = _a;
    b = _b;
    printf("MIN(++%d, ++%d) => %d\n", _a, _b, MIN(++a, ++b));

    printf("\nAh, much better now.\n\n");

    return 0;
}

Журнал консоли :

NAIVE_MAX(3, 5) => 5
NAIVE_MIN(3, 5) => 3
MAX(3, 5) => 5
MIN(3, 5) => 3

Everything fine so far...

NAIVE_MAX(3++, 5++) => 6
NAIVE_MIN(3++, 5++) => 4
NAIVE_MAX(++3, ++5) => 7
NAIVE_MIN(++3, ++5) => 5

Ouch, this doesn't look right at all!

MAX(3++, 5++) => 5
MIN(3++, 5++) => 3
MAX(++3, ++5) => 6
MIN(++3, ++5) => 4

Ah, much better now.

Итак, никогда не используйте наивную реализацию , как показано в приведенном выше коде (и как было предложено Брэндоном Боднаром, извини, приятель;)), если вы хотите избежать наихудших случаев, подобных этим.