"Template<>" VS "Template" Without Brackets - What's the Difference

template<> vs template without brackets - what's the difference?

template <> void foo<int>(int& t); declares a specialization of the template, with potentially different body.

template void foo<int>(int& t); causes an explicit instantiation of the template, but doesn't introduce a specialization. It just forces the instantiation of the template for a specific type.

What is the difference between parentheses, brackets and asterisks in Angular2?

All details can be found here: https://angular.io/docs/ts/latest/guide/template-syntax.html

• directiveName - is the short hand form for structural directives where the long form can only be applied to <template> tags. The short form implicitely wraps the element where it's applied in a <template>.

• [prop]="value" is for object binding to properties (@Input() of an Angular component or directive or a property of a DOM element).
  
  There are special forms:

  • [class.className] binds to a css class to enable/disable it
  • [style.stylePropertyName] binds to a style property
  • [style.stylePropertyName.px] binds to a style property with a preset unit
  • [attr.attrName] binds a value to an attribute (visible in the DOM, while properties are not visible)
  • [role.roleName] binds to the ARIA role attribute (not yet available)

• prop="{{value}}" binds a value to a property. The value is stringified (aka interpolation)

• (event)="expr" binds an event handler to an @Output() or DOM event

• #var or #var has different functions depending on the context

  • In an *ngFor="#x in y;#i=index" scope variables for the iteration are created
    (In beta.17 this is changed to *ngFor="let x in y; let i=index"`)
  • On a DOM element <div #mydiv> a reference to the element
  • On an Angular component a reference to the component
  • On an element that is an Angular component or has an Angular directive where exportAs:"ngForm" is defined, #myVar="ngForm" creates a reference to this component or directive.

C++ template full specialization syntax

You just confused explicit instantiation and template specialization.

No1 is template spcialization, means you want to define a special version for the template with the given type, so you have to provide a potentially different defination for it.

No2 is explicit instantiation, means you want the compiler to instantiate the template with the given type explicitly. It will be generated based on the primary template.

Explicit instantiation:

An explicit instantiation definition forces instantiation of the
function or member function they refer to. It may appear in the
program anywhere after the template definition, and for a given
argument-list, is only allowed to appear once in the program.

An explicit instantiation declaration (an extern template) prevents
implicit instantiations: the code that would otherwise cause an
implicit instantiation has to use the explicit instantiation
definition provided somewhere else in the program.

explicit (full) template specialization:

Allows customizing the template code for a given set of template arguments.

What is the meaning of template<> with empty angle brackets in C++?

template<> tells the compiler that a template specialization follows, specifically a full specialization. Normally, class A would have to look something like this:

template<class T>
class A{
  // general implementation
};

template<>
class A<int>{
  // special implementation for ints
};

Now, whenever A<int> is used, the specialized version is used. You can also use it to specialize functions:

template<class T>
void foo(T t){
  // general
}

template<>
void foo<int>(int i){
  // for ints
}

// doesn't actually need the <int>
// as the specialization can be deduced from the parameter type
template<>
void foo(int i){
  // also valid
}

Normally though, you shouldn't specialize functions, as simple overloads are generally considered superior:

void foo(int i){
  // better
}

---

And now, to make it overkill, the following is a partial specialization:

template<class T1, class T2>
class B{
};

template<class T1>
class B<T1, int>{
};

Works the same way as a full specialization, just that the specialized version is used whenever the second template parameter is an int (e.g., B<bool,int>, B<YourType,int>, etc).

specializing member S::display requires ‘template<>’ syntax

Your functions : display and area should be write like this:

    template <>
    double operations<Rectangle>::area( Rectangle const& rect )
    {
            double width =  get<0>(rect);
            double height = get<1>(rect);

            return width * height;
    }

• As for template specialized functions, template <> should be placed
  at the head of the function.
• For static member functions, static should not appear at the
  definition body of the function.

What is the difference between {{}} and [[]] in the template data binding in Polymer?

From https://www.polymer-project.org/1.0/docs/devguide/data-binding

Binding annotation
Text surrounded by double curly bracket ({{ }}) or double square bracket ([[ ]]) delimiters. Identifies the host data being bound.
Compound binding
A string literal containing one or more binding annotations.

Whether data flow goes down from host to target, up from target to host, or both ways is controlled by the type of binding annotation and
the configuration of the target property.

• Double-curly brackets (}) support both upward and downward data flow.

• Double square brackets ([[ ]]) are one-way, and support only only downward data flow.

template specialization on std::vector<T>

You cannot partially specialize a function, you want to create a new overload:

template <class C>
void foo(C c);

template <class V>
void foo(std::vector<V> v); // This is a different overload, not a specialization!

Please note the difference with a partial specialization of foo:

template <class C>
void foo(C c); // 1

template <class V>
void foo<std::vector<V>>(std::vector<V> v); // 2

Here 2 is a partial specialization of 1, which is not allowed in C++ for function.

---

Related Topics