1

My program grabs command line arguements with argc and argv[]. My question is how can I find the length of argv[1][i].

My code that grabs length of argv[]

int my_strlen(char input[]){ 
    int len = 0;
    while(input[len] != '\0'){
       ++len;
    }
    return len;
}

but when I try to find argv[1][len] I get a subscripted value is neither array nor pointer: my attempt

int my_strlen(char input[]){
   int len = 0;
   while((input[1][len] - '0') != '\0'){
      ++len;
   }
   return len;
}

FULL CODE:

#include <stdio.h>
#include <math.h>

int my_strlen(char input[]);

int main(int argc, char *argv[]){
int length = 0;
length = my_strlen(argv[1]);
long numberArr[length];
int i, j;

for(i = 0; i < length; i++){
  numberArr[i] = argv[1][i] - '0';
}

 return 0;
}

int my_strlen(char input[]){
 int len = 0;
 while((input[1][len] - '0') != '\0'){
  ++len;
 }
 return len;
}

Thanks for any help in advance!

Improve this question
2
  • 1
    argv is a 2-dimensional array of characters (char), meaning that it is a 1-dimensional array of strings. Commented Feb 1, 2011 at 3:58
  • @Gabe: Thanks, I'm in the early stages of learning C, so since there is no string type in C I've been a little confused when people refer to them as "strings". But thank you for your help! Commented Feb 1, 2011 at 5:05

2 Answers 2

Reset to default
3

I think you're confused about the argv content. The OS will pass a number of ASCIIZ strings, such that invoking my_program with arguments ala...

my_program first second third

...is similar to having the following declaration in your program...

int argc = 4;
const char* argv[4] = { "my_program", "first", "second", "third" };

Hence, when you index into argv[1][i] you're getting the i-th character in the string "first". That's only valid for values of i between 0 (which yields 'f'), and 5 (which indexes to the terminating NUL character '\0').

So, there no two-dimensional N*M array, but there is an array of pointers-to-(array-of-char). You can invoke the normal strlen() function as in strlen(argv[1]) to find out the number of characters in each argument. Only argc tells you the total number of elements in argv.

Does that help?

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

Okay, I think I understand, So I should treat argv[1] as a string and use strlen(argv[1]) in order to get string length? I was using this before and was getting sometimes getting a segmentation fault error
@Grant: Yes, that's the right approach. Did you check argc before trying to use argv[1]? If you forget to provide a command line argument, then you can't use strlen(argv[1]). That's pretty easy to do in shells where some environment variable might not be set etc.. Remember too that the program name is argv[0] and accounts for argc of 1, hence the last argument is still only argv[argc - 1]. Put another way, check argc > 1 to make sure you've got an argv[1]. If you do find you've still got a problem, do post the broken code.
To clarify, there's a difference between a two dimensional array of characters, and an array of strings (char pointers). Imagine a case where (making addresses up) argv[0] = 0x123456. argv[1] could potentially be 0x055555. argv is not the same thing as a matrix of chars...
@Tony: Yes I have it checking argc (first thing I do). I'm not sure what exactly was being inputted into it that made it return a segmentation error because I'm using a separate program that the professor uses to grade it (I'll have to mess with it). Quick question, the const before char* argv[4] declares it as a string? (I know there isn't a string type in C).
@Grant: the const just asks the compiler to generate an error if you accidentally try to modify the characters that the pointer points to. Normally, that's a good idea for argv as it's rare that you want to modify them but could accidentally change them, producing confusing bugs. It's an excellent idea when creating a pointer to string literals (e.g. "quoted text in your program"), as the OS probably loads them into read-only memory and will fail at run-time if you try to write to them: better to know about the problem at compile time.
1

In main, you're passing argv[1] to my_strlen. That means my_strlen just receives a normal, single-dimension string. It doesn't need to do input[1][len], just input[len].

Improve this answer

3 Comments

I had that before. However, sometimes I would get a segmentation fault which is why I was trying it a bit different
Even with that fixed, my_strlen() looped while input[len] - '0' != '\0': but the "- '0'" is effectively saying subtract the numeric value used to encode the character zero/'0' (in ASCII, 48 decimal), and make sure the result's not the numeric value used to encode the character '\0' (always 0). Given "x - y != 0" is equivalent to "x != y", you're just saying loop until you find a zero/'0' character. But, you do want to check for ASCII NUL/'\0' - just use while (input[len] != '\0'), or equivalently while (input[len]), which leverages C interpreting 0 as false, non-0 as true.
@Grant: looking again, you have another problem. The end of a string is signaled by a character with the value '\0', so your while loop should be more like while (input[len] != '\0').

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.