Sont les Modèles C++ seulement les Macros dans le déguisement?

Les Macros sont un texte mécanisme de substitution.

Modèles sont une fonctionnelle de turing-complet de la langue qui est exécuté au moment de la compilation, et est intégré dans le C++ type de système. Vous pouvez y penser comme à un plugin mécanisme de la langue.

Il y a beaucoup de commentaires ici, en essayant de différencier les macros et les modèles.

Oui, ils sont tous les deux la même chose: outils de génération de Code.

Macros sont une forme primitive, sans beaucoup de compilateur application de la loi (comme faire des Objets en C - il peut être fait, mais c'est pas joli). Les modèles sont plus avancés, et ont beaucoup mieux compilateur vérification de type, les messages d'erreur, etc.

Cependant, chacune a des points forts que les autres ne le sont pas.

Modèles ne peut que générer des dynamiques types de classe - les macros peuvent générer presque tous les code que vous voulez (autre que la définition de macro). Les Macros peuvent être très utiles pour intégrer des tableaux statiques de données structurées dans votre code.

Modèles sur l'autre main peut accomplir certains vraiment FUNKY choses qui ne sont pas possible avec des macros. Par exemple:

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

Le modèle permet au compilateur de créer de façon dynamique et l'utilisation de type sécurisé des instances du modèle à la volée. Le compilateur fait en fait le modèle de paramètre de mathématiques au moment de la compilation, de la création de classes séparées pour chaque résultat unique. Il y a un implicite de l'Unité de<1,-1> (distance /temps = vitesse) de type qui est créé et par rapport à l'intérieur de la conditionnelle, mais jamais explicitement déclaré dans le code.

Apparemment, quelqu'un à une université a défini un modèle de ce genre avec plus de 40 paramètres (besoin d'une référence), chacun représentant un physique type d'unité. Pensez à la sécurité de ce genre de classe, juste pour vos numéros.

Sur un niveau très basique, oui, du modèle sont juste macro remplacements. Mais vous êtes sauter sur l' beaucoup de choses en pensant à elle de cette façon.

Envisager modèle de spécialisation, ce qui, à ma connaissance, vous ne pouvez pas simuler avec macro. Non seulement le fait de permettre, ainsi, spécial de la mise en œuvre de certains types, il est l'un des éléments clés dans le modèle de méta-programmation:

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

Ce qui en soi n'est qu'un exemple de la beaucoup de choses que vous pouvez faire. Les modèles eux-mêmes sont Turing-complet.

Il ignore les choses très basiques, tels que la portée, type de sécurité, et que les macro sont messier.

Modèles C++ sont un peu comme Lisp les macros (non C macros) dans lesquelles ils opèrent déjà analysé version du code, et qu'ils vous permettent de générer du code arbitraire au moment de la compilation. Malheureusement, la programmation dans quelque chose ressemblant à la crue Lambda calcul, de sorte que des techniques comme le bouclage sont un peu lourdes. Pour tous les détails sanglants, voir Générative de Programmation par Krysztof Czarnecki et Ulrich Eisenecker.

• modèles sont typesafe.
• basé sur un modèle d'objets de types peuvent être des espaces, privés des membres d'une classe, etc.
• paramètres basés sur des modèles de fonctions ne sont pas répliquées sur l'ensemble du corps de la fonction.

Ce sont vraiment un gros problème et éviter une multitude de bugs.

Non, il n'est pas possible. Le préprocesseur est (à peine) suffisante pour quelques choses comme des conteneurs de T, mais c'est tout simplement insuffisant pour quelques choses d'autres modèles peuvent faire.

Pour des exemples concrets, de lire à travers Moderne de la Programmation en C++, par André Alexandrescu, ou C++ Métaprogrammation par Dave Abrahams et Aleksey Gurtovoy. À peu près rien faire dans les deux livres peuvent être simulées pour plus de extrêmement degré minimal, avec le préprocesseur.

Edit: autant Que typename va, l'exigence est assez simple. Le compilateur ne peut pas toujours déterminer si une personne à charge nom fait référence à un type ou pas. À l'aide de typename explicitement indique au compilateur qu'il se réfère à un type.

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 indique au compilateur qu'un nom particulier est destiné à se référer à un type, pas une variable/valeur, de sorte que (par exemple), vous pouvez définir d'autres variables de ce type.

Essayons primitive exemple. Envisager

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

invoquée comme

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

Bien sûr, la vraie différence est plus profonde, mais qui devrait être suffisant pour rejeter similitudes avec les macros.

Modifier: Et non, vous ne pouvez pas assurer la sécurité de type avec des macros. Comment voulez-vous mettre en œuvre typesafe min() pour chaque type de définition de moins de comparaison (c'est à dire operrator<)?

Modèles peuvent être mis dans des espaces de noms, ou être membres d'une classe. Les Macros sont juste une pré-étape de traitement. Fondamentalement, les modèles sont un premier membre de la classe de la langue qui joue de nice (plus agréable?) avec tout le reste.

À mon avis, les macros sont une mauvaise habitude de C. Bien qu'ils peuvent être utiles pour certains, je ne vois pas un réel besoin pour eux quand il y a des typedefs et des modèles. Les modèles sont le prolongement naturel de la Programmation Orientée Objet. Vous pouvez faire beaucoup plus avec les modèles...

Considérer cette...

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

Afin de faire la conversion vous pouvez utiliser quelque chose qui s'appelle une conversion d'un constructeur et d'un constructeur de séquence (à la fin) le long de la plutôt complet exemple pour une liste:

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

Ont un look à la de l'information à partir de cplusplus.com sur les modèles! Vous pouvez utiliser des modèles pour faire ce qu'on appelle des traits qui est utilisé a une sorte de documentation pour les types et les tels. Vous pouvez faire beaucoup plus avec des modèles puis ce qui est possible avec les macros!

Modèles comprendre les types de données. Les Macros ne sont pas.

Cela signifie que vous pouvez faire des choses comme la suivante...

• Définir une opération (par exemple, un pour emballage numéros) qui peut prendre n'importe quel type de données, puis de fournir les spécialisations qui choisir l'algorithme approprié selon que le type de données est une partie intégrante ou à virgule flottante
• De déterminer les aspects de vos types de données au moment de la compilation, permettant à des astuces comme modèle de déduction de la taille de la matrice, que Microsoft utilise pour son C++ surcharges de strcpy_s et de ses semblables

En outre, étant donné que les modèles sont de type sécuritaire, il y a un certain nombre de modèle de techniques de codage qui pourrait être réalisée avec un hypothétique avancée de préprocesseur, mais serait encombrants et sujettes à l'erreur, au mieux (par exemple, modèle de paramètres de modèle, le modèle par défaut, les arguments, les modèles de stratégie tel que discuté dans Modern C++ Design).

Modèles ne sont semblables à des macros dans leur la plupart des fonctionnalités de base. Après tout, les modèles ont été introduits dans la langue comme "civilisé" alternative à des macros. Mais même quand il s'agit de ce que la plupart des fonctionnalités de base, la similitude est que la peau en profondeur.

Cependant, une fois que nous obtenons pour les fonctionnalités plus avancées de modèles, comme la spécialisation (partielle ou explicite) apparente similitude avec les macros disparaît entièrement.

Ce n'est pas une réponse tellement comme une conséquence de l'réponses déjà dit.

De travail avec des scientifiques, des chirurgiens, des artistes graphiques et d'autres qui ont besoin de programme - mais ne le sont pas et ne seront jamais professionnel à plein temps, les développeurs de logiciels - je vois que les macros sont facilement comprises par le programmeur occasionnel, tandis que les modèles semblent exiger un niveau plus élevé de la pensée abstraite possible seulement avec la plus profonde et l'expérience en cours de programmation en C++. Il prend de nombreux cas de travail avec le code où les modèles sont utiles concept, le concept de donner un sens suffisamment pour les utiliser. Tout ce qu'on peut dire de tout le langage, le montant de l'expérience pour les modèles présente un écart plus grand que le spécialiste casual programmeur est susceptible d'obtenir à partir de leur travail de tous les jours.

La moyenne de l'astronome, ingénieur en électronique, probablement groks macros très bien, et peut même comprendre pourquoi les macros doivent être évités, mais ne connaît pas les modèles bien assez pour un usage quotidien. Dans ce contexte, les macros sont en fait mieux. Naturellement, il existe de nombreuses poches des exceptions; certains physiciens exécuter des cercles autour de la pro ingénieurs en logiciel, mais ce n'est pas typique.

Modèles sont intégrés dans la langue et sont de type sécurisé.

Dites-moi comment vous voulez faire cela avec des macros. C'est lourd modèle de la métaprogrammation.

https://www.youtube.com/watch?v=0A9pYr8wevk

Je pense que les macros, autant que je sache, ne peut pas calculer les types de la façon dont ce modèle partielle spécialisations peuvent le faire.