pass-by-value

Since we always use pointers to define variables, I was wondering if Objective-C is "pass by value", since like Java, the actual value would be passed by using its reference. However, since it seems to be built up on top of C, would it have all the functionality of C? C does not support pass-by-reference and Objective-C, being a strict superset of C doesn't either. In C (and Objective-C) you can simulate pass-by-reference by passing a pointer, but it's important to remember that you're still technically passing a value, which happens to be a the value of a pointer. So, in Objective-C (and C,

Are arrays passed by default by ref or value? Thanks. They are passed as pointers. This means that all information about the array size is lost. You would be much better advised to use std::vectors, which can be passed by value or by reference, as you choose, and which therefore retain all their information. Here's an example of passing an array to a function. Note we have to specify the number of elements specifically, as sizeof(p) would give the size of the pointer. int add( int * p, int n ) { int total = 0; for ( int i = 0; i < n; i++ ) { total += p[i]; } return total; } int main() { int a[

Yes, I know it sounds silly but i have no idea what i'm doing wrong! The function is part of a poker game, in which there are 10 functions, each which checks for a specific poker hand. If activated, the function prints the line "Player 1 has a full house!" or whatever the hand might be. But, i also need to increment the value of p1, in which p1 is a global variable the holds the total score for p1. Printing the line works perfectly, but when i want to assign, for example, a value of 10 to p1, it simply doesn't assign. In the example below, the printfs work perfectly when they should, but the

Should a C++ (implicit or explicit) value constructor accept its parameter(s) by value or reference-to-const, when it needs to store a copy of the argument(s) in its object either way? Here is the shortest example I can think of: struct foo { bar _b; foo(bar [const&] b) // pass by value or reference-to-const? : _b(b) { } }; The idea here is that I want to minimize the calls to bar's copy constructor when a foo object is created, in any of the various ways in which a foo object might get created. Please note that I do know a little bit about copy elision and (Named) Return Value Optimization,

This question already has an answer here: Why the sequence-operation algorithms predicates are passed by copy? 3 answers So I asked a question here: Lambda Works on Latest Visual Studio, but Doesn't Work Elsewhere to which I got the response, that my code was implementation defined since the standard's 25.1 [algorithms.general] 10 says: Unless otherwise specified, algorithms that take function objects as arguments are permitted to copy those function objects freely. Programmers for whom object identity is important should consider using a wrapper class that points to a noncopied implementation

I have just read the classic book "Effective C++, 3rd Edition", and in item 20 the author concludes that built-in types, STL iterators and function object types are more appropriate for pass-by-value . I could well understand the reason for built-in and iterators types, but why should the function object be pass-by-value , as we know it is class-type anyway? In a typical case, a function object will have little or (more often) no persistent state. In such a case, passing by value may no require actually passing anything at all -- the "value" that's passed is basically little or nothing more