Arrow operator (- ) in function heading
In C++11, there are two syntaxes for function declaration:
return-type identifier (
argument-declarations... )
and
auto
identifier (
argument-declarations... )
->
return_type
They are equivalent. Now when they are equivalent, why do you ever want to use the latter? Well, C++11 introduced this cool decltype
thing that lets you describe type of an expression. So you might want to derive the return type from the argument types. So you try:
template <typename T1, typename T2>
decltype(a + b) compose(T1 a, T2 b);
and the compiler will tell you that it does not know what a
and b
are in the decltype
argument. That is because they are only declared by the argument list.
You could easily work around the problem by using declval
and the template parameters that are already declared. Like:
template <typename T1, typename T2>
decltype(std::declval<T1>() + std::declval<T2>())
compose(T1 a, T2 b);
except it's getting really verbose now. So the alternate declaration syntax was proposed and implemented and now you can write
template <typename T1, typename T2>
auto compose(T1 a, T2 b) -> decltype(a + b);
and it's less verbose and the scoping rules didn't need to change.
C++14 update: C++14 also permits just
auto
identifier (
argument-declarations... )
as long as the function is fully defined before use and all return
statements deduce to the same type. The ->
syntax remains useful for public functions (declared in the header) if you want to hide the body in the source file. Somewhat obviously that can't be done with templates, but there are some concrete types (usually derived via template metaprogramming) that are hard to write otherwise.
What does - mean in Python function definitions?
It's a function annotation.
In more detail, Python 2.x has docstrings, which allow you to attach a metadata string to various types of object. This is amazingly handy, so Python 3 extends the feature by allowing you to attach metadata to functions describing their parameters and return values.
There's no preconceived use case, but the PEP suggests several. One very handy one is to allow you to annotate parameters with their expected types; it would then be easy to write a decorator that verifies the annotations or coerces the arguments to the right type. Another is to allow parameter-specific documentation instead of encoding it into the docstring.
taking input using gets with arrow operator not working? What's the Error?
Your struc
have been created wrong. So i changed your code like this to make it clear. I also did use getchar()
function so you can call fget()
function multiplie times. I guess it does work like you wish.
#include <stdio.h>
struct Emp{
char name[100];
int salary;
};
void func(struct Emp *e){
printf("enter name : ");
fgets(e->name, sizeof(e->name), stdin);
printf("enter salary : ");
scanf("%d", &e->salary);
getchar();
}
int main() {
struct Emp e1,e2;
func(&e1);
func(&e2);
printf("\n%s , %d", e1.name,e1.salary);
printf("\n%s , %d", e2.name,e2.salary);
return 0;
}
What's the meaning of = (an arrow formed from equals & greater than) in JavaScript?
What It Is
This is an arrow function. Arrow functions are a short syntax, introduced by ECMAscript 6, that can be used similarly to the way you would use function expressions. In other words, you can often use them in place of expressions like function (foo) {...}
. But they have some important differences. For example, they do not bind their own values of this
(see below for discussion).
Arrow functions are part of the ECMAscript 6 specification. They are not yet supported in all browsers, but they are partially or fully supported in Node v. 4.0+ and in most modern browsers in use as of 2018. (I’ve included a partial list of supporting browsers below).
You can read more in the Mozilla documentation on arrow functions.
From the Mozilla documentation:
An arrow function expression (also known as fat arrow function) has a shorter syntax compared to function expressions and lexically binds the
this
value (does not bind its ownthis
,arguments
,super
, ornew.target
). Arrow functions are always anonymous. These function expressions are best suited for non-method functions and they can not be used as constructors.
A Note on How this
Works in Arrow Functions
One of the most handy features of an arrow function is buried in the text above:
An arrow function... lexically binds the
this
value (does not bind its ownthis
...)
What this means in simpler terms is that the arrow function retains the this
value from its context and does not have its own this
. A traditional function may bind its own this
value, depending on how it is defined and called. This can require lots of gymnastics like self = this;
, etc., to access or manipulate this
from one function inside another function. For more info on this topic, see the explanation and examples in the Mozilla documentation.
Example Code
Example (also from the docs):
var a = [
"We're up all night 'til the sun",
"We're up all night to get some",
"We're up all night for good fun",
"We're up all night to get lucky"
];
// These two assignments are equivalent:
// Old-school:
var a2 = a.map(function(s){ return s.length });
// ECMAscript 6 using arrow functions
var a3 = a.map( s => s.length );
// both a2 and a3 will be equal to [31, 30, 31, 31]
Notes on Compatibility
You can use arrow functions in Node, but browser support is spotty.
Browser support for this functionality has improved quite a bit, but it still is not widespread enough for most browser-based usages. As of December 12, 2017, it is supported in current versions of:
- Chrome (v. 45+)
- Firefox (v. 22+)
- Edge (v. 12+)
- Opera (v. 32+)
- Android Browser (v. 47+)
- Opera Mobile (v. 33+)
- Chrome for Android (v. 47+)
- Firefox for Android (v. 44+)
- Safari (v. 10+)
- iOS Safari (v. 10.2+)
- Samsung Internet (v. 5+)
- Baidu Browser (v. 7.12+)
Not supported in:
- IE (through v. 11)
- Opera Mini (through v. 8.0)
- Blackberry Browser (through v. 10)
- IE Mobile (through v. 11)
- UC Browser for Android (through v. 11.4)
- QQ (through v. 1.2)
You can find more (and more current) information at CanIUse.com (no affiliation).
What does - mean in C++?
It's to access a member function or member variable of an object through a pointer, as opposed to a regular variable or reference.
For example: with a regular variable or reference, you use the .
operator to access member functions or member variables.
std::string s = "abc";
std::cout << s.length() << std::endl;
But if you're working with a pointer, you need to use the ->
operator:
std::string* s = new std::string("abc");
std::cout << s->length() << std::endl;
It can also be overloaded to perform a specific function for a certain object type. Smart pointers like shared_ptr
and unique_ptr
, as well as STL container iterators, overload this operator to mimic native pointer semantics.
For example:
std::map<int, int>::iterator it = mymap.begin(), end = mymap.end();
for (; it != end; ++it)
std::cout << it->first << std::endl;
Related Topics
Sending an Email from a C/C++ Program in Linux
About the Binary Compatibility of Linux
Opencv Videocapture Lag Due to the Capture Buffer
In C++, Is It Safe/Portable to Use Static Member Function Pointer for C API Callbacks
C++ Standard Library and Boehm Garbage Collector
Purpose of Trigraph Sequences in C++
Floating Point Equality and Tolerances
Determine If Linux or Windows in C++
Openprocess/Readprocessmemory/Writeprocessmemory/Closehandle Equivalent
While (1) VS. for (;;) Is There a Speed Difference
How to Compare Multiple Strings Inside an If Statement
":" (Colon) in C Struct - What Does It Mean
Force Gcc to Notify About Undefined References in Shared Libraries