C/C++-传值/地址的区别

2. Can you give an example based on passing a value versus an address?

Let’s consider an example in C where we compare passing a value (by value) with passing an address (by pointer). We’ll use a simple function that modifies a data item to illustrate the difference.
Example: Passing by Value

#include <stdio.h>

void incrementByValue(int num) 
{
   num += 1; // Increment the copy of the variable
}

int main() 
{
   int a = 5;
  incrementByValue(a); // Passes a copy of 'a' to the function
   printf("a after incrementByValue: %d\n", a); // 'a' remains unchanged
   return 0;
}

In this example, incrementByValue receives a copy of the variable a. Changes made to num inside the function do not affect a in the main function.
Example: Passing by Address

#include <stdio.h>

void incrementByPointer(int *num) 
{
   *num += 1; // Increment the actual variable pointed by 'num'
}

int main() 
{
   int a = 5;
   incrementByPointer(&a); // Passes the address of 'a' to the function
   printf("a after incrementByPointer: %d\n", a); // 'a' is changed
   return 0;
}

In this second example, incrementByPointer receives a pointer to a. Changes made to the value pointed to by num affect the original variable a in the main function.
Conclusion
Passing by Value: The function gets a copy of the data, and modifications inside the function do not affect the original variable.
Passing by Address: The function gets a pointer to the data, and modifications are made to the original variable.
Passing by value is generally used when you don’t need to modify the original variable or when dealing with simple data types. Passing by address is used when you need to modify the original variable or when passing large/complex data types to avoid the overhead of copying.

3. “when passing large/complex data types to avoid the overhead of copying” Give an example of this situation?

Let’s consider an example where we have a large data structure, such as a big array or a struct with multiple fields. In this case, passing the entire structure by value (making a copy) can be inefficient due to the overhead of copying all the data. Passing a pointer or reference to the structure is much more efficient, as it avoids this overhead.
Example: Passing a Large Structure
Suppose we have a large structure representing a 3D model with many vertices:

#include <stdio.h>

#define NUM_VERTICES 1000

typedef struct 
{
   float x, y, z;
} Vertex;

typedef struct 
{
   Vertex vertices[NUM_VERTICES];
} Model;

// Function to translate the model by some offset
void translateModel(Model *model, float offsetX, float offsetY, float offsetZ) 
{
   for (int i = 0; i < NUM_VERTICES; i++) 
   {
       model->vertices[i].x += offsetX;
       model->vertices[i].y += offsetY;
       model->vertices[i].z += offsetZ;
   }
}

int main() 
{
   Model myModel;

   // Initialize myModel with some data
   // ...

   // Translate the model
   translateModel(&myModel, 1.0, 1.0, 1.0);

   // Further processing...
   // ...

   return 0;
}

In this example:
We define a Model struct containing an array of 1000 Vertex structs.
The translateModel function translates each vertex of the model by an offset. It takes a pointer to a Model instead of the whole Model object.
In the main function, we pass the address of myModel to translateModel.
Efficiency of Passing by Address
Memory Efficiency: Only the address of myModel is passed to translateModel, not the entire structure. This is much more efficient than copying the entire Model structure, which contains 1000 Vertex structures.
Performance: Passing a large structure by value can significantly slow down the program, especially in performance-critical applications like graphics, simulations, or large-scale data processing.
Functionality: By passing the address, any modifications translateModel makes to myModel will be reflected in the myModel object in the main function.
In summary, for large or complex data types like this, passing by address is more efficient in terms of both memory and performance. It also allows the function to modify the original data structure.