Шаблоны C++ - это всего лишь замаскированные макросы?

Они анализируются компилятор, а не препроцессором, который запускает компилятор до.

Вот что об этом говорит MSDN: http://msdn.microsoft.com/en-us/library/aa903548(VS.71).aspx

Here are some problems with the macro:

• There is no way for the compiler to verify that the macro parameters are of compatible types.
• The macro is expanded without any special type checking.
• The i and j parameters are evaluated twice. For example, if either parameter has a postincremented variable, the increment is performed two times.
• Because macros are expanded by the preprocessor, compiler error messages will refer to the expanded macro, rather than the macro definition itself. Also, the macro will show up in expanded form during debugging.

Если вам этого мало, я не знаю, что.

Шаблоны предлагают некоторую степень безопасности типов.

Макросы - это механизм подстановки текста.

Шаблоны - это функциональный полный по Тьюрингу язык, который выполняется во время компиляции и интегрирован в систему типов C++. Вы можете думать о них как о механизме подключаемых модулей для языка.

Шаблоны безопасны по типу. С помощью определений у вас может быть код, который компилируется, но все равно работает некорректно.

Макросы раскрываются до того, как компилятор перейдет к коду. Это означает, что вы получите сообщение об ошибке для расширенного кода, а отладчик видит только расширенную версию.

С макросами всегда есть шанс, что какое-то выражение будет вычислено дважды. Представьте, что вы передаете что-то вроде ++ x в качестве параметра.

Шаблоны могут быть помещены в пространства имен или быть членами класса. Макросы - это всего лишь этап предварительной обработки. По сути, шаблоны - это первоклассный член языка, который хорошо сочетается (лучше?) Со всем остальным.

Шаблоны C++ похожи на макросы Lisp (не макросы C) в том, что они работают с уже проанализированной версией кода и позволяют генерировать произвольный код во время компиляции. К сожалению, вы программируете в чем-то похожем на необработанное лямбда-исчисление, поэтому продвинутые методы, такие как циклы, довольно громоздки. Для всех кровавых подробностей см. Генеративное программирование Крыштофа Чарнецкого и Ульриха Эйзенекера.

Если вы хотите более подробно изучить эту тему, я могу обратиться к каждому любимый ненавистник C++. Этот человек знает и ненавидит C++ больше, чем я могу когда-либо мечтать. Это одновременно делает FQA невероятно подстрекательским и отличным ресурсом.

Шаблоны могут делать гораздо больше, чем препроцессор макросов.

Например. есть специализации шаблона: Если этот шаблон создан с этим типом или константой, то не используйте реализацию по умолчанию, а вот эту ...

... шаблоны могут требовать, чтобы некоторые параметры были одного типа и т. д.

Вот некоторые источники, на которые вы, возможно, захотите посмотреть:

• Шаблоны C++ от Вандервурде и Джоссутиса. Это лучшая и самая полная книга о шаблонах, которую я знаю.
• Библиотека ускорения почти полностью состоит из определений шаблонов.

Здесь много комментариев, пытающихся различить макросы и шаблоны.

Да, это одно и то же: инструменты генерации кода.

Макросы - это примитивная форма, без особого применения компилятора (например, выполнение объектов в C - это можно сделать, но это некрасиво). Шаблоны являются более продвинутыми и имеют намного лучшую проверку типов компилятора, сообщения об ошибках и т. д.

Однако у каждого есть сильные стороны, которых нет у другого.

Шаблоны могут генерировать только динамические типы классов - макросы могут генерировать практически любой код, который вы хотите (кроме другого определения макроса). Макросы могут быть очень полезны для встраивания статических таблиц структурированных данных в ваш код.

С другой стороны, с помощью шаблонов можно делать действительно ЗАБЫВНЫЕ вещи, которые невозможны с макросами. Например:

template<int d,int t> class Unit
{
    double value;
public:
    Unit(double n)
    {
        value = n;
    }
    Unit<d,t> operator+(Unit<d,t> n)
    {
        return Unit<d,t>(value + n.value);
    }
    Unit<d,t> operator-(Unit<d,t> n)
    {
        return Unit<d,t>(value - n.value);
    }
    Unit<d,t> operator*(double n)
    {
        return Unit<d,t>(value * n);
    }
    Unit<d,t> operator/(double n)
    {
        return Unit<d,t>(value / n);
    }
    Unit<d+d2,t+t2> operator*(Unit<d2,t2> n)
    {
        return Unit<d+d2,t+t2>(value * n.value);
    }
    Unit<d-d2,t-t2> operator/(Unit<d2,t2> n)
    {
        return Unit<d-d2,t-t2>(value / n.value);
    }
    etc....
};

#define Distance Unit<1,0>
#define Time     Unit<0,1>
#define Second   Time(1.0)
#define Meter    Distance(1.0)

void foo()
{
   Distance moved1 = 5 * Meter;
   Distance moved2 = 10 * Meter;
   Time time1 = 10 * Second;
   Time time2 = 20 * Second;
   if ((moved1 / time1) == (moved2 / time2))
       printf("Same speed!");
}

Шаблон позволяет компилятору динамически создавать и использовать типобезопасные экземпляры шаблона на лету. Компилятор фактически выполняет математические вычисления параметров шаблона во время компиляции, создавая отдельные классы там, где это необходимо для каждого уникального результата. Существует подразумеваемый тип Unit <1, -1> (расстояние / время = скорость), который создается и сравнивается в условном выражении, но никогда явно не объявляется в коде.

По-видимому, кто-то в университете определил шаблон такого типа с более чем 40 параметрами (требуется ссылка), каждый из которых представляет отдельный тип физических единиц. Подумайте о безопасности типов такого класса только для ваших чисел.

Что не было упомянуто, так это то, что функции шаблонов могут определять типы параметров.

template <typename T>
void func(T t)
{
  T make_another = t;

Кто-то может возразить, что предстоящий оператор typeof может исправить это, но даже он не может разбить другие шаблоны:

template <typename T>
void func(container<T> c)

или даже:

template <tempate <typename> class Container, typename T>
void func(Container<T> ct)

Я также считаю, что предмет специализации был недостаточно освещен. Вот простой пример того, чего не могут делать макросы:

template <typename T>
T min(T a, T B)
{
  return a < b ? a : b;
}

template <>
char* min(char* a, char* b)
{
  if (strcmp(a, b) < 0)
    return a;
  else
    return b;
}

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

Это не столько ответ, сколько следствие уже изложенных ответов.

Работая с учеными, хирургами, художниками-графиками и другими людьми, которым нужно программировать, но которые не являются и никогда не будут профессиональными разработчиками программного обеспечения на полную ставку, я вижу, что макросы легко понимаются случайным программистом, в то время как шаблоны, похоже, требуют более высокого Уровень абстрактного мышления возможен только при более глубоком и постоянном опыте программирования на C++. Требуется много экземпляров работы с кодом, где шаблоны являются полезной концепцией, чтобы концепция приобрела достаточный смысл для использования. Хотя это можно сказать о любой языковой функции, количество опыта работы с шаблонами представляет собой больший пробел, чем обычный программист-специалист может получить от своей повседневной работы.

Среднестатистический астроном или инженер-электронщик, вероятно, отлично разбирается в макросах, может даже понимать, почему следует избегать макросов, но не будет достаточно хорошо разбираться в шаблонах для повседневного использования. В этом контексте макросы действительно лучше. Естественно, существует множество исключений; некоторые физики бегают по кругу профессиональных инженеров-программистов, но это нетипично.

Хотя параметры шаблона проверяются по типу и у шаблонов есть много преимуществ перед макросами, шаблоны очень похожи на макросы в том, что они по-прежнему основаны на подстановке текста. Компилятор не будет проверять, имеет ли код шаблона какой-либо смысл, пока вы не предоставите ему параметры типа для замены. Visual C++ не жалуется на эту функцию, пока вы ее не вызываете:

template<class T>
void Garbage(int a, int b)
{
    fdsa uiofew & (a9 s) fdsahj += *! wtf;
}

Редактировать: Этот пример применим только к Visual C++. В стандарт C++ код вашего шаблона фактически анализируется в дерево синтаксиса до того, как шаблон когда-либо будет использован, поэтому пример принимается VC++, но не GCC или Clang. (Я узнал это, когда попытался перенести код VC++ в GCC и столкнулся с сотнями синтаксических ошибок в моих неспециализированных шаблонах.) Однако синтаксическое дерево все еще не обязательно имеет смысл семантически. Независимо от компилятора, проверка типа в теле не выполняется, пока вы не создадите экземпляр шаблона, предоставив <template arguments>.

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

На мой взгляд, макросы - плохая привычка для C. Хотя они могут быть полезны для некоторых, я не вижу в них реальной необходимости, когда есть определения типов и шаблоны. Шаблоны являются естественным продолжением объектно-ориентированного программирования. Вы можете сделать гораздо больше с помощью шаблонов ...

Учти это...

int main()
{
    SimpleList<short> lstA;
    //...
    SimpleList<int> lstB = lstA; //would normally give an error after trying to compile
}

Чтобы выполнить преобразование, вы можете использовать что-то, что называется конструктором преобразования и конструктором последовательности (см. Конец) в довольно полном примере для списка:

#include <algorithm>

template<class T>
class SimpleList
{
public:
    typedef T value_type;
    typedef std::size_t size_type;

private:
    struct Knot
    {
        value_type val_;
        Knot * next_;
        Knot(const value_type &val)
        :val_(val), next_(0)
        {}
    };
    Knot * head_;
    size_type nelems_;

public:
    //Default constructor
    SimpleList() throw()
    :head_(0), nelems_(0)
    {}
    bool empty() const throw()
    { return size() == 0; }
    size_type size() const throw()
    { return nelems_; }

private:
    Knot * last() throw() //could be done better
    {
        if (empty()) return 0;
        Knot *p = head_;
        while (p->next_)
            p = p->next_;
        return p;
    }

public:
    void push_back(const value_type & val)
    {
        Knot *p = last();
        if (!p)
            head_ = new Knot(val);
        else
            p->next_ = new Knot(val);
        ++nelems_;
    }
    void clear() throw()
    {
        while(head_)
        {
            Knot *p = head_->next_;
            delete head_;
            head_ = p;
        }
        nelems_ = 0;
    }
    //Destructor:
    ~SimpleList() throw()
    { clear(); }
    //Iterators:
    class iterator
    {
        Knot * cur_;
    public:
        iterator(Knot *p) throw()
        :cur_(p)
        {}
        bool operator==(const iterator & iter)const throw()
        { return cur_ == iter.cur_; }
        bool operator!=(const iterator & iter)const throw()
        { return !(*this == iter); }
        iterator & operator++()
        {
            cur_ = cur_->next_;
            return *this;
        }
        iterator operator++(int)
        {
            iterator temp(*this);
            operator++();
            return temp;
        }
        value_type & operator*()throw()
        { return cur_->val_; }
        value_type operator*() const
        { return cur_->val_; }
        value_type operator->()
        { return cur_->val_; }
        const value_type operator->() const
        { return cur_->val_; }
    };
    iterator begin() throw()
    { return iterator(head_); }
    iterator begin() const throw()
    { return iterator(head_); }
    iterator end() throw()
    { return iterator(0); }
    iterator end() const throw()
    { return iterator(0); }
    //Copy constructor:
    SimpleList(const SimpleList & lst)
    :head_(0), nelems_(0)
    {
        for(iterator i = lst.begin(); i != lst.end(); ++i)
            push_back(*i);
    }
    void swap(SimpleList & lst) throw()
    {
        std::swap(head_, lst.head_);
        std::swap(nelems_, lst.nelems_);
    }
    SimpleList & operator=(const SimpleList & lst)
    {
        SimpleList(lst).swap(*this);
        return *this;
    }
    //Conversion constructor
    template<class U>
    SimpleList(const SimpleList<U> &lst)
    :head_(0), nelems_(0)
    {
        for(typename SimpleList<U>::iterator iter = lst.begin(); iter != lst.end(); ++iter)
            push_back(*iter);
    }
    template<class U>
    SimpleList & operator=(const SimpleList<U> &lst)
    {
        SimpleList(lst).swap(*this);
        return *this;
    }
    //Sequence constructor:
    template<class Iter>
    SimpleList(Iter first, Iter last)
    :head_(0), nelems_(0)
    {
        for(;first!=last; ++first)
            push_back(*first);


    }
};

Взгляните на информация с cplusplus.com о шаблонах! Вы можете использовать шаблоны для того, что называется чертами, которые используются, есть своего рода документация для типов и тому подобное. Вы можете сделать гораздо больше с помощью шаблонов, чем то, что возможно с помощью макросов!

Ответ такой длинный, что я не могу подытожить все, но:

• например, макросы не обеспечивают безопасность типов, в то время как шаблоны функций делают:
  Компилятор не может проверить, являются ли параметры макроса совместимыми типами - также во время создания экземпляра шаблона функции компилятор знает, определяет ли int или floatoperator +.
• шаблоны открывают дверь для метапрограммирования (короче говоря, оценки вещей и принятия решения во время компиляции):
  Во время компиляции можно узнать, является ли тип целым или с плавающей запятой; будь то указатель или квалифицированный констант, и т. д. см. «характеристики типа» в готовящемся к выпуску C++ 0x.
• шаблоны классов имеют частичную специализацию
• шаблоны функций имеют явную полную специализацию, в вашем примере add<float>(5, 3); может быть реализован иначе, чем add<int>(5, 3);, что невозможно с макросами
• макрос не имеет области видимости
• #define min(i, j) (((i) < (j)) ? (i) : (j)) - параметры i и j оцениваются дважды. Например, если какой-либо параметр имеет постинкрементную переменную, приращение выполняется два раза.
• поскольку макросы раскрываются препроцессором, сообщения об ошибках компилятора будут относиться к расширенному макросу, а не к самому определению макроса. Кроме того, макрос будет отображаться в развернутом виде во время отладки.
• так далее...

Примечание. В некоторых редких случаях я предпочитал полагаться на макросы с переменным числом аргументов, потому что до тех пор, пока C++ 0x не станет мейнстримом, такой вещи, как вариативные шаблоны, не существует.C++ 11 в прямом эфире.

Использованная литература:

• C++ FAQ Lite: [35] Шаблоны
• Преимущества шаблонов (в отставке, можно скачать)
• Шаблоны против макросов (C++) (в отставке, можно скачать)

НЕТ. Один простой встречный пример: шаблоны подчиняются пространствам имен, макрос игнорирует пространства имен (поскольку они являются операторами препроцессора).

namespace foo {
    template <class NumberType>
    NumberType add(NumberType a, NumberType b)
    {
        return a+b;
    }

    #define ADD(x, y) ((x)+(y))
} // namespace foo

namespace logspace 
{
    // no problemo
    template <class NumberType>
    NumberType add(NumberType a, NumberType b)
    {
        return log(a)+log(b);
    }

    // redefintion: warning/error/bugs!
    #define ADD(x, y) (log(x)+log(y))

} // namespace logspace

Да, на самом базовом уровне шаблоны - это просто замена макросов. Но вы пропускаете много вещей, думая об этом таким образом.

Рассмотрим специализацию шаблона, которую, насколько мне известно, вы не можете смоделировать с помощью макросов. Это не только дает возможность специальной реализации для определенных типов, но и является одной из ключевых частей метапрограммирования шаблонов:

template <typename T>
struct is_void
{
    static const bool value = false;
}

template <>
struct is_void<void>
{
    static const bool value = true;
}

Что само по себе является лишь одним примером много вещей, которые ты можешь сделать. Сами шаблоны являются полными по Тьюрингу.

Это игнорирует самые основные вещи, такие как область видимости, безопасность типов и эти макросы более беспорядочные.

• шаблоны безопасны для типов.
• шаблонные объекты / типы могут иметь пространство имен, быть закрытыми членами класса и т. д.
• параметры шаблонных функций не реплицируются по всему телу функции.

Это действительно большое дело и предотвращает множество ошибок.

Этот ответ призван пролить свет на препроцессор C и то, как его можно использовать для общего программирования.

В некотором смысле они допускают схожую семантику. Препроцессор C использовался для включения общих структур данных и алгоритмов (см. конкатинация токена). Однако, без учета каких-либо других функций шаблонов C++, он превращает общую игру программирования в ЛОТ ЧИСТЕ для чтения и реализации.

Если кто-то хочет увидеть в действии хардкорное базовое программирование на C, прочтите исходный код Libevent - это также упоминается здесь. Реализован обширный набор контейнеров / алгоритмов, и это делается в заголовочном файле НЕ ЗАМУЖЕМ (очень читаемом). Я действительно восхищаюсь этим, код шаблона C++ (который я предпочитаю из-за других его атрибутов) ОЧЕНЬ многословен.

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

Для некоторых реальных примеров прочтите Современное программирование на C++ Андре Александреску или C++ Метапрограммирование Дэйва Абрахамса и Алексея Гуртового. Практически ничего из того, что написано в обеих книгах, не может быть смоделировано с помощью препроцессора в большей степени, чем крайне минимальная.

Обновлено: Что касается typename, требование довольно простое. Компилятор не всегда может определить, относится ли зависимое имя к типу или нет. Использование typename явно сообщает компилятору, что он ссылается на тип.

struct X { 
    int x;
};

struct Y {
    typedef long x;
};

template <class T>
class Z { 
    T::x;
};

Z<X>; // T::x == the int variable named x
Z<Y>; // T::x == a typedef for the type 'long'

typename сообщает компилятору, что конкретное имя предназначено для ссылки на тип, а не на переменную / значение, поэтому (например) вы можете определить другие переменные этого типа.

Ключевое слово typename используется для включения контекстно-свободных вложенных определений типов. Они были необходимы для метода признаков, который позволяет добавлять метаданные к типам (особенно встроенным типам, таким как указатель), это требовалось для записи STL. В остальном ключевое слово typename совпадает с ключевым словом class.

Попробуем примитивный пример. Рассматривать

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

вызывается как

c = min(a++,++b);

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

Редактировать: И нет, вы не можете обеспечить безопасность типов с помощью макросов. Как бы вы реализовали безопасный тип min() для каждого типа, определяющего меньше, чем сравнение (например, operrator<)?

Шаблоны понимать типы данных. Макросы нет.

Это означает, что вы можете делать что-то вроде следующего ...

• Определите операцию (например, для упаковка чисел), которая может принимать любой тип данных, затем предоставьте специализации, которые выбирают соответствующий алгоритм в зависимости от того, является ли тип данных целочисленным или с плавающей запятой.
• Определите аспекты ваших типов данных во время компиляции, разрешив такие уловки, как шаблонное вычитание размера массива, который Microsoft использует для своих перегрузок C++ для strcpy_s и ему подобных.

Кроме того, поскольку шаблоны являются типобезопасными, существует ряд методов кодирования шаблонов, которые предположительно могут быть выполнены с помощью некоторого гипотетического продвинутого препроцессора, но в лучшем случае будут беспорядочными и подверженными ошибкам (например, параметры шаблона шаблона, аргументы шаблона по умолчанию, шаблоны политики, как описано Современный дизайн C++).

Шаблоны похожи на макросы только в их основных функциях. Ведь шаблоны были введены в язык как «цивилизованная» альтернатива макросам. Но даже когда дело доходит до этой самой базовой функциональности, сходство только поверхностное.

Однако, как только мы перейдем к более продвинутым функциям шаблонов, таким как специализация (частичная или явная), всякое очевидное сходство с макросами полностью исчезнет.

Есть несколько основных проблем с макросами.

Во-первых, они не уважают объем или тип. Если у меня #define max(a, b)..., то всякий раз, когда в моей программе присутствует токен max, по какой-либо причине он будет заменен. Он будет заменен, если это имя переменной или глубоко внутри вложенных областей видимости. Это может вызвать труднодоступные ошибки компиляции. Напротив, шаблоны работают внутри системы типов C++. Имя шаблонной функции может быть повторно использовано внутри области видимости, и она не будет пытаться переписать имя переменной.

Во-вторых, макросы нельзя изменять. Шаблон std::swap обычно просто объявляет временную переменную и выполняет очевидные назначения, потому что это очевидный способ, который обычно работает. Это то, чем был бы ограничен макрос. Это было бы крайне неэффективно для больших векторов, поэтому у векторов есть специальный swap, который меняет местами ссылки, а не весь контент. (Это оказывается очень важным для тех вещей, которые среднестатистический программист на C++ не должен писать, но использует.)

В-третьих, макросы не могут выполнять какие-либо формы вывода типов. Во-первых, вы не можете написать общий макрос подкачки, потому что он должен объявлять переменную типа, а он не знает, каким может быть тип. Шаблоны распознают типы.

Отличным примером мощи шаблонов является то, что изначально называлось Стандартной библиотекой шаблонов, которая входит в стандартную комплектацию как контейнеры, алгоритмы и итераторы. Посмотрите, как они работают, и попробуйте подумать, как бы вы заменили их макросами. Александр Степанов просмотрел большое количество языков для реализации своих идей STL и пришел к выводу, что C++ с шаблонами - единственный язык, на котором он будет работать.

Шаблоны интегрированы в язык и безопасны по типу.

Подскажите, как бы вы это сделали с помощью макросов. Это тяжелое метапрограммирование шаблонов.

https://thewikihow.com/video_0A9pYr8wevk

Я думаю, что макросы, AFAIK, не могут вычислять типы так, как это могут делать частичные специализации шаблонов.