C函数实现 - 使用Pointer vs without Pointer

Question

I've just started to work with C, and never had to deal with pointers in previous languages I used, so I was wondering what method is better if just modifying a string.

pointerstring vs normal.

Also if you want to provide more information about when to use pointers that would be great. I was shocked when I found out that the function "normal" would even modify the string passed, and update in the main function without a return value.

#include <stdio.h>

void pointerstring(char *s);
void normal(char s[]);

int main() {
    char string[20];
    pointerstring(string);
    printf("\nPointer: %s\n",string);
    normal(string);
    printf("Normal: %s\n",string);
}

void pointerstring(char *s) {
    sprintf(s,"Hello");
}
void normal(char s[]) {
    sprintf(s,"World");
}

Output:

Pointer: Hello
Normal: World

Answer 1

In a function declaration, char [] and char * are equivalent. Function parameters with outer-level array type are transformed to the equivalent pointer type; this affects calling code and the function body itself.

Because of this, it's better to use the char * syntax as otherwise you could be confused and attempt eg to take the sizeof of an outer-level fixed-length array type parameter:

void foo(char s[10]) {
    printf("%z\n", sizeof(s));  // prints 4 (or 8), not 10
}

When you pass a parameter declared as a pointer to a function (and the pointer parameter is not declared const ), you are explicitly giving the function permission to modify the object or array the pointer points to.

Answer 2

One of the problems in C is that arrays are second-class citizens. In almost all useful circumstances, among them when passing them to a function, arrays decay to pointers (thereby losing their size information).

Therefore, it makes no difference whether you take an array as T* arg or T arg[] — the latter is a mere synonym for the former . Both are pointers to the first character of the string variable defined in main() , so both have access to the original data and can modify it.

---

Note: C always passes arguments per copy . This is also true in this case. However, when you pass a pointer (or an array decaying to a pointer), what is copied is the address , so that the object referred to is accessible through two different copies of its address.

Answer 3

With pointer Vs Without pointer

1) We can directly pass a local variable reference(address) to the new function to process and update the values, instead of sending the values to the function and returning the values from the function.

With pointers

...
int a = 10;
func(&a);
...

void func(int *x);
{
   //do something with the value *x(10)
   *x = 5;
}

Without pointers

...
int a = 10;
a = func(a);
...

int func(int x);
{
   //do something with the value x(10)
   x = 5;
   return x;
}

2) Global or static variable has life time scope and local variable has scope only to a function. If we want to create a user defined scope variable means pointer is requried. That means if we want to create a variable which should have scope in some n number of functions means, create a dynamic memory for that variable in first function and pass it to all the function, finally free the memory in nth function.

3) If we want to keep member function also in sturucture along with member variables then we can go for function pointers.

struct data;

struct data
{
    int no1, no2, ans;
    void (*pfAdd)(struct data*);
    void (*pfSub)(struct data*);    
    void (*pfMul)(struct data*);
    void (*pfDiv)(struct data*);
};

void add(struct data* x)
{
   x.ans = x.no1, x.no2;
}
...
struct data a;
a.no1 = 10;
a.no1 = 5;
a.pfAdd = add;
...
a.pfAdd(&a);
printf("Addition is %d\n", a.ans);
...

4) Consider a structure data which size s is very big. If we want to send a variable of this structure to another function better to send as reference. Because this will reduce the activation record(in stack) size created for the new function.

With Pointers - It will requires only 4bytes (in 32 bit m/c) or 8 bytes (in 64 bit m/c) in activation record(in stack) of function func

...
struct data a;
func(&a);
...

Without Pointers - It will requires s bytes in activation record(in stack) of function func . Conside the s is sizeof(struct data) which is very big value.

...
struct data a;
func(a);
...

5) We can change a value of a constant variable with pointers.

...
const int a = 10;
int *p = NULL;
p = (int *)&a;
*p = 5;
printf("%d", a); //This will print 5
...

Answer 4

in addition to the other answers, my comment about "string"-manipulating functions (string = zero terminated char array): always return the string parameter as a return value.

So you can use the function procedural or functional, like in printf("Dear %s, ", normal(buf));