i += Increment(ref i); is equivalent to i = i + Increment(ref i); The expression on the right hand side of the assignment is evaluated from left to right, so the next step is i = 0 + Increment(ref i); return i++ returns the current value of i (which is 0), then increments i i … Read more
A leading slash tells the browser to start at the root directory. If you don’t have the leading slash, you’re referencing from the current directory. If you add two dots before the leading slash, it means you’re referencing the parent of the current directory. Take the following folder structure notice: the ROOT checkmark is green, … Read more
A small modification to f2 provides the clue: template<class T> void f2(T arg) { arg.get() = xx; } This now does what you expect. This has happened because std::ref returns a std::reference_wrapper<> object. The assignment operator of which rebinds the wrapper. (see http://en.cppreference.com/w/cpp/utility/functional/reference_wrapper/operator%3D) It does not make an assignment to the wrapped reference. In the … Read more
You should think of using std::ref when a function: takes a template parameter by value copies/moves a template parameter, such as std::bind or the constructor for std::thread. std::ref creates a copyable value type that behaves like a reference. This example makes demonstrable use of std::ref. #include <iostream> #include <functional> #include <thread> void increment( int &x … Read more
Well ref constructs an object of the appropriate reference_wrapper type to hold a reference to an object. Which means when you apply: auto r = ref(x); This returns a reference_wrapper and not a direct reference to x (ie T&). This reference_wrapper (ie r) instead holds T&. A reference_wrapper is very useful when you want to … Read more
Short answer: read my article on argument passing. Long answer: when a reference type parameter is passed by value, only the reference is passed, not a copy of the object. This is like passing a pointer (by value) in C or C++. Changes to the value of the parameter itself won’t be seen by the … Read more
Pass a ref if you want to change what the object is: TestRef t = new TestRef(); t.Something = “Foo”; DoSomething(ref t); void DoSomething(ref TestRef t) { t = new TestRef(); t.Something = “Not just a changed t, but a completely different TestRef object”; } After calling DoSomething, t does not refer to the original … Read more
For ‘out’, the following seems to work for me. public interface IService { void DoSomething(out string a); } [TestMethod] public void Test() { var service = new Mock<IService>(); var expectedValue = “value”; service.Setup(s => s.DoSomething(out expectedValue)); string actualValue; service.Object.DoSomething(out actualValue); Assert.AreEqual(expectedValue, actualValue); } I’m guessing that Moq looks at the value of ‘expectedValue’ when you … Read more
ref tells the compiler that the object is initialized before entering the function, while out tells the compiler that the object will be initialized inside the function. So while ref is two-ways, out is out-only.