Is this correct : passing strings?

Code:

---

#include <stdio.h>

int main(int argc, char **argv)
{
        char *name = NULL;

        name = argv[1];

        printf("Name is %s\n", name);

        return 0;
}

---

I'm trying to learn weather or not this is a correct way to due the above.
Is this insecure?

If it is how can I make it correct?
I will not know the length of the input.

WOuld I have to malloc?
Thank you

Where are you trying to pass something? You mean into printf? All you need for printf is a pointer to the memory where the string is, which conveniently is exactly what argv[1] is.

Anyway, the memory behind argv[whatever] is given to you by the OS, more or less; the command-line arguments are placed there before your program starts.

Code:

---

#include <stdio.h>

int main(int argc, char** argv)
{
        if (argc >= 1)
                printf("Name is &#37;s\n", argv[1]);
        return 0;
}

---

Simplification.
And added security, in case no argument was passed.

I am wanting to put argv[1] in my variable name.

For example.

I know I can do the following.

char *name = "myname";
char buf[10];

strcpy(buf,name);

But is my above post doing the same thing?

It is not doing the same thing as above.
You are reassigning a pointer. And you do know what a pointer is, do you not?

I'm simply wanting to take in any argument (string) and allocate enough size to a variable so I can store the input ot a variable.
I don't want to have a set size. (ie: char buf[10];)
Input may be longer than 10.
So I'd like to have char *buf;
Then allocated the exact length needed from input to store the input to buf.

Can you help?

Sure.
First, get the size of the input; strlen will help with that.
Then add +1 to that for the null terminator.
Then use malloc to allocate the space.
Then copy it over using strcpy.

I suppose the first question is "why" -- you already have such a thing; it's called "argv[1]". If for some reason you want a copy, then you can strlen + 1 on what you have to find out how much room you need.

Code:

---

#include <string.h>    // for strlen and strcpy
#include <stdlib.h>    // for exit
#include <stdio.h>    // for printf

int main (int argc, char *argv[]) {
    char *name;
    if (argc < 2) exit (-1);
    if ((name=malloc(strlen(argv[1]+1))) == NULL) exit (-2);
    strcpy(name,argv[1]);
    printf("Name is %s.\n",name);
    free(name);
    return 0;
}

---

This is how you allocate memory for a string to and copy into it. Don't miss out the red bits.

Thank you very much.

Please tell me what happens if you do not free(name); ?

It will become a memory leak.

How does this effect the system?
Once the program is killed is there still a memory leak?
How do you fix the memory leak once this happened?

However, after it's freed the string "in" your pointer will be gone, so free it when you are done, or before you reassign it.

The "memory leak" is gone when the program stops, so in the above example it is sort of unnecessary, but...

It affects the system in that your application eats more and more memory because it failed to free previous memory - it's gone. The application cannot use it again, so it just sits there, eating away at valuable ram while doing nothing.
Most operating systems free up any resources when an application exits, but not all! The majority here at cboard agree that we think it is good practice to free up anything you allocate - even if it's freed when the application quits.
And lastly, you can't fix a memory leak once it has happened. That's why it's a memory leak in the first place.

Here's some pseudocode that demonstrates why free is important:

Code:

---

while (condition) {    // a looping construct in which "name" gets reused
    name=malloc(strlen(input)+1);
    strcpy(name,input);            // the new content
    (use name, etc.)
    free(name);
}

---

This will work fine without free(), but every time you call malloc, MORE memory is allocated and the pointer is reassigned to this new, unused chunk. If "name" was pointing to a string in memory, that previous chunk of memory is preserved as part of the program, but there is no longer a pointer to it so it's just wasted and unusable. By calling free() at the end of the loop, the space occupied by the data pointed to by "name" is returned to the heap, since we are done using it. This way, the amount of memory consumed may change depending on the strlen of "input", but it will not accumulate with each iteration of the loop (10 bytes + 12 bytes + 8 bytes, and so on) which would be a "memory leak" since the memory you are losing remains held by the process but cannot be used because it has no pointer.