unary-operator

Was the unary + operator only included for symmetry with the unary - operator, or does it find some practical use in C++ code? Searching here, I came across What is the purpose of the unary '+' operator in C? , but the only useful scenarios there involve preprocessor macros. Those are good to know, but they seem to be some less common situations, and involve macros. Are there any use cases involving more common C++ code? char ch = 'a'; std::cout << ch << '\n'; std::cout << +ch << '\n'; The first insertion writes the character a to cout . The second insertion writes the numeric value of ch to

in my bash script, I have a function to return 0 or 1(true or false) for the later main function's condition. function1 () { if [[ "${1}" =~ "^ ...some regexp... $" ]] ; then return 1 else return 0 fi } then in my main function: main () { for arg in ${@} ; do if [ function1 ${arg} ] ; then ... elif [ ... ] ; then ... fi done } however, when i ran this script it always gave me an error msg "[: function1: unary operator expected" can anyone help me please? You are making the common mistake of assuming that [ is part of the if command's syntax. It is not; the syntax of if is simply if command;

Apart from making a nice symmetry with unary minus, why is unary plus operator defined on Numeric class? Is there some practical value in it, except for causing confusion allowing writing things like ++i (which, unlike most non-Rubyists would think, doesn't increment i ). I can think of scenario where defining unary plus on a custom class could be useful (say if you're creating some sexy DSL), so being able to define it is ok, but why is it already defined on Ruby numbers? Perhaps it's just a matter of consistency, both with other programming languages, and to mirror the unary minus. Found

The C++ operator precedence table from http://en.cppreference.com/w/cpp/language/operator_precedence (I know it's not normative, but the standard doesn't talk about precedence or associativity) marks unary operators as right/left associative. From a discussion on a different question, I'm left with doubts. Does it make sense for unary operators to be associative? It's just an artefact of the way that the associativity is derived from the grammar. The reason that addition is left-associative is that one of the productions for additive-expression is additive-expression + multiplicative

Possible Duplicate: Ruby/Ruby on Rails ampersand colon shortcut As a habit I try and read a little of someone elses source code regularly and comment on it in a gist. Right now I'm reading through sinatra's base app and came upon an interesting bit of code (this is part of their Request class) def accept @env['sinatra.accept'] ||= begin entries = @env['HTTP_ACCEPT'].to_s.split(',') entries.map { |e| accept_entry(e) }.sort_by(&:last).map(&:first) end end The part I don't get is what is &:last and &:first doing?!? It appears as madness! Read the answers in the duplicate questions for the meaning

I was perusing the underscore.js library and I found something I haven't come across before: if (obj.length === +obj.length) { ... } What is that + operator doing there? For context, here is a direct link to that part of the file. The unary + operator can be used to convert a value to a number in JavaScript. Underscore appears to be testing that the .length property is a number, otherwise it won't be equal to itself-converted-to-a-number. According to MDN : The unary plus operator precedes its operand and evaluates to its operand but attempts to converts it into a number, if it isn't already.

What is the difference between += and =+? Specifically, in java, but in general also. i += 4; means i = i + 4; // increase i by 4. While i =+ 4; is equivalent to i = +4; // assign 4 to i. the unary plus is effectively no-op. (See http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.15.3 for what a unary + does.) += is an operator that increments the left-hand side of the assignment by the value of the right-hand side and assigns it back to the variable on the left-hand side. =+ is not an operator but, in fact, two operators: the assignment operator = and the unary plus +