荒野求生: C Language

Showing posts with label C Language. Show all posts

Saturday, December 27, 2014

Getopt

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int
main (int argc, char **argv)
{
  int aflag = 0;
  int bflag = 0;
  char *cvalue = NULL;
  int index;
  int c;

  opterr = 0;

  while ((c = getopt (argc, argv, "abc:")) != -1)
    switch (c)
      {
      case 'a':
        aflag = 1;
        break;
      case 'b':
        bflag = 1;
        break;
      case 'c':
        cvalue = optarg;
        break;
      case '?':
        if (optopt == 'c')
          fprintf (stderr, "Option -%c requires an argument.\n", optopt);
        else if (isprint (optopt))
          fprintf (stderr, "Unknown option `-%c'.\n", optopt);
        else
          fprintf (stderr,
                   "Unknown option character `\\x%x'.\n",
                   optopt);
        return 1;
      default:
        abort ();
      }

  printf ("aflag = %d, bflag = %d, cvalue = %s\n",
          aflag, bflag, cvalue);

  for (index = optind; index < argc; index++)
    printf ("Non-option argument %s\n", argv[index]);
  return 0;
}

Here are some examples showing what this program prints with different combinations of arguments:

% testopt
aflag = 0, bflag = 0, cvalue = (null)

% testopt -a -b
aflag = 1, bflag = 1, cvalue = (null)

% testopt -ab
aflag = 1, bflag = 1, cvalue = (null)

% testopt -c foo
aflag = 0, bflag = 0, cvalue = foo

% testopt -cfoo
aflag = 0, bflag = 0, cvalue = foo

% testopt arg1
aflag = 0, bflag = 0, cvalue = (null)
Non-option argument arg1

% testopt -a arg1
aflag = 1, bflag = 0, cvalue = (null)
Non-option argument arg1

% testopt -c foo arg1
aflag = 0, bflag = 0, cvalue = foo
Non-option argument arg1

% testopt -a -- -b
aflag = 1, bflag = 0, cvalue = (null)
Non-option argument -b

% testopt -a -
aflag = 1, bflag = 0, cvalue = (null)
Non-option argument -

An option character in this string can be followed by a colon (‘:’) to indicate that it takes a required argument. If an option character is followed by two colons (‘::’), its argument is optional.

This optarg is set by getopt to point at the value of the option argument, for those options that accept arguments.

Reference

[1] http://www.gnu.org/software/libc/manual/html_node/Using-Getopt.html

[2] http://www.gnu.org/software/libc/manual/html_node/Example-of-Getopt.html

[3] http://en.wikipedia.org/wiki/Getopt

Sunday, November 30, 2014

Array initialization

Basic initialization

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };

other syntax

int myArray[10] = { [4] = 5, [2] = 5 };

is equivalent to

int myArray[6] = { 0, 0, 5, 0, 5, 0 };

initialize a range of elements to the same value

int myArray[10] = {[0 ... 9] = 5};

Elements with missing values will be initialized to 0:

int myArray[10] = { 1, 2 }; // initialize to 1,2,0,0,0...

So this will initialize all elements to 0:

int myArray[10] = { 0 }; // all elements 0(only for Zero initial)

Remember that objects with static storage duration will initialize to 0 if no initializer is specified:

static int myArray[10]; // all elements 0

In C++, an empty initialization list will also initialize every element to 0. This is not allowed with C:

int myArray[10] = {}; // all elements 0 in C++

And that "0" doesn't necessarily mean "all-bits-zero", so using the above is better and more portable than memset(). (Floating point values will be initialized to +0, pointers to null value, etc.)
Reference
[1] http://stackoverflow.com/questions/201101/how-to-initialize-an-array-in-c
[2] https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html
[3] http://www.lemoda.net/c/array-initialization/ (experiment)

Sunday, November 16, 2014

Inline Functions versus Macros

add my commend into the content

Inline functions follow all the protocols of type safety enforced on normal functions.

more safe then the macro, especially, for the type defination.
for the type check, macro is checked by prepocessor, and inline functions is checked by compilar.

Inline functions are specified using the same syntax as any other function except that they include the inline keyword in the function declaration.

only difference is keyword “inline”

Expressions passed as arguments to inline functions are evaluated once. In some cases, expressions passed as arguments to macros can be evaluated more than once.

more variable for arguments

There is no risk if called multiple times. But there is risk in macros which can be dangerous when the argument is an expression.
functions can include multiple lines of code without trailing backlashes.
functions have thier own scope for variables and they can return a value.
debuging

Reference

[1] http://msdn.microsoft.com/en-us/library/bf6bf4cf.aspx

[2] http://www.thegeekstuff.com/2013/04/c-macros-inline-functions/

Friday, November 14, 2014

function and function-like macro

if we use the same name for those things. avoid the prepocessor will expand the function first, we usaully add parenthese to prevent.

simple example

#include <stdio.h>
#define test(x) __test(x)
#define __test(x) printf("\n%d\n", x + 1);

int test(int x);
#undef test

int main()
{
test(1);
}
int (test)(int x)
{
printf("\n%d\n", x);
}

Referemce

http://stackoverflow.com/questions/13600790/what-do-the-parentheses-around-a-function-name-mean

Thursday, November 6, 2014

In C, Keyword “static”

#include <stdio.h>
 
int global_var;        //statically allocated as a global variable
static int static_var; //statically allocated but only accessible within file
 
void my_function(void){
     static int my_static = 0; //statically allocated, accessible within my_function
     int my_stack = 0; //allocated on the stack
 
     printf("my_static:%d, my_stack:%d\n", my_static, my_stack);
     my_stack++;
     my_static++;
}

Answer:

my_static:0, my_stack:0
my_static:1, my_stack:0
my_static:2, my_stack:0
my_static:3, my_stack:0
my_static:4, my_stack:0

Reference

[1] http://coactionos.com/embedded%20design%20tips/2013/10/18/Tips-RAM-Flash-Usage-in-Embedded-C-Programs/

RAM/Flash Usage in Embedded C Programs

Read-only memory(Flash)

Data Section

int data_variable = 500;

Read-only date

constant

const int read_only_variable = 2000;

Text(code)

“literal pool” may in the function.

void my_function(void){
     int x;
     x = 200;
     printf("X is %d\n", x);
}

Read-Write Data(RAM)

Data section

int data_var = 500; //require flash memory to stored.

BSS section

int bss_var0;
int bss_var1 = 0;

//doesn’t need require flash memory to stored.

Heap section

static int static_var;

buffer = malloc(512);

Stack section

int my_function(int a, int b, int c, int d)

Reference

[1] http://coactionos.com/embedded%20design%20tips/2013/10/18/Tips-RAM-Flash-Usage-in-Embedded-C-Programs/

Sunday, October 26, 2014

Declarations

C 99 provide programmer a way to save a memory space.

struct DM {

int x,

char* z[]

}

z just a label, compilar won’t allocate a memory for that, and this declaration only could put in last of structure declaration. therefore if we need to allocate a space for this structure when we need to store a data in variable z, otherwise we will assign wrong address which is next to variable x.

Reference

[1] C in a nutshell