Return to array CVS log

Up to [MW Coherent from dump] / coherent / a / usr / man / ALL

Annotation of coherent/a/usr/man/ALL/array, revision 1.1

1.1     ! root        1: 
        !             2: 
        !             3: array                       Definition                      array
        !             4: 
        !             5: 
        !             6: 
        !             7: 
        !             8: An array is a concatenation of data elements, all of which are of
        !             9: the same type.  All the  elements of an array are stored consecu-
        !            10: tively in  memory, and each  element within the array  can be ad-
        !            11: dressed by the array name plus a subscript.
        !            12: 
        !            13: For example,  the array  int foo[3]  has three elements,  each of
        !            14: which  is an  iinntt.  The  three iinntts  are stored  consecutively in
        !            15: memory, and  each can be addressed  by the array name  ffoooo plus a
        !            16: subscript that indicates  its place within the array, as follows:
        !            17: foo[0], foo[1], and  foo[2].  Note that the numbering of elements
        !            18: within an array always begins with `0'.
        !            19: 
        !            20: Arrays,  like  other  data  elements,  may be  automatic  (aauuttoo),
        !            21: static, or external (eexxtteerrnn).
        !            22: 
        !            23: Arrays can be multi-dimensional;  that is to say, each element in
        !            24: an array can itself  be an array.  To declare a multi-dimensional
        !            25: array, use  more than one  set of square  brackets.  For example,
        !            26: the multi-dimensional array foo[3][10] is a two-dimensional array
        !            27: that  has  three elements,  each  of  which is  an  array of  ten
        !            28: elements.  The second  sub-script is always necessary in a multi-
        !            29: dimensional  array,  whereas  the  first  is not.   For  example,
        !            30: foo[][10]  is acceptable,  whereas foo[10][]  is not.   The first
        !            31: form is an indefinite number of ten-element arrays, which is cor-
        !            32: rect C,  whereas the second  form is ten copies  of an indefinite
        !            33: number of elements, which is illegal.
        !            34: 
        !            35: You can initialize automatic arrays and structures, provided that
        !            36: you know the size of the  array, or of any array contained within
        !            37: a structure.  An automatic  array is initialized in the same man-
        !            38: ner as aggregate, but initialization is performed on entry to the
        !            39: routine at run time, instead of at compile time.
        !            40: 
        !            41: ***** Flexible Arrays *****
        !            42: 
        !            43: A flexible array is  one whose length is not declared explicitly.
        !            44: Each has exactly one empty `[ ]' array-bound declaration.  If the
        !            45: array is  multidimensional, the  flexible dimension of  the array
        !            46: must be the _f_i_r_s_t array bound in the declaration; for example:
        !            47: 
        !            48: 
        !            49:         int example1[][20];     /* RIGHT */
        !            50:         int example2[20][];     /* WRONG */
        !            51: 
        !            52: 
        !            53: The C language allows you  to declare an indefinite number of ar-
        !            54: ray  elements of  a set  length, but  not a  set number  of array
        !            55: elements of an indefinite length.
        !            56: 
        !            57: Flexible arrays  occur in  only a  few contexts; for  example, as
        !            58: parameters:
        !            59: 
        !            60: 
        !            61: 
        !            62: 
        !            63: 
        !            64: COHERENT Lexicon                                           Page 1
        !            65: 
        !            66: 
        !            67: 
        !            68: 
        !            69: array                       Definition                      array
        !            70: 
        !            71: 
        !            72: 
        !            73:         char *argv[];
        !            74:         char p[][8];
        !            75: 
        !            76: 
        !            77: as extern declarations:
        !            78: 
        !            79: 
        !            80:         extern int end[];
        !            81: 
        !            82: 
        !            83: or as a member of a structure -- usually, though not necessarily,
        !            84: the last:
        !            85: 
        !            86: 
        !            87:         struct nlist {
        !            88:                 struct nlist *next;
        !            89:                 char name[];
        !            90:         };
        !            91: 
        !            92: 
        !            93: ***** Example *****
        !            94: 
        !            95: The following program  initializes an automatic array, and prints
        !            96: its contents.
        !            97: 
        !            98: 
        !            99: main()
        !           100: {
        !           101:         int foo[3] = { 1, 2, 3 };
        !           102: 
        !           103: 
        !           104: 
        !           105:         printf("Here's foo's contents: %d %d %d\n",
        !           106:                  foo[0], foo[1], foo[2]);
        !           107: }
        !           108: 
        !           109: 
        !           110: ***** See Also *****
        !           111: 
        !           112: definitions, struct
        !           113: _T_h_e _C _P_r_o_g_r_a_m_m_i_n_g _L_a_n_g_u_a_g_e, ed. 2, pages 25, 83, 210
        !           114: 
        !           115: 
        !           116: 
        !           117: 
        !           118: 
        !           119: 
        !           120: 
        !           121: 
        !           122: 
        !           123: 
        !           124: 
        !           125: 
        !           126: 
        !           127: 
        !           128: 
        !           129: 
        !           130: COHERENT Lexicon                                           Page 2
        !           131: 
        !           132: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.