Return to block.3 CVS log

Up to [Research Unix] / researchv10dc / man / adm / man3

Annotation of researchv10dc/man/adm/man3/block.3, revision 1.1

1.1     ! root        1: .TH BLOCK 3+
        !             2: .CT 2 datatype
        !             3: .SH NAME
        !             4: block \- adjustable arrays
        !             5: .SH SYNOPSIS
        !             6: .nf
        !             7: .B "#include <Block.h>"
        !             8: .PP
        !             9: .ds T \fIT\fP
        !            10: .ft L
        !            11: Blockdeclare(\*T)
        !            12: Blockimplement(\*T)
        !            13: .PP
        !            14: .ft L
        !            15: struct Block(\*T) {
        !            16:        Block(\*T)(unsigned = 0);
        !            17:        Block(\*T)(const Block(\*T&);
        !            18:        ~Block(\*T);
        !            19:        Block(\*T)& operator= (const Block(\*T)&);
        !            20:        \*T& operator[] (int);
        !            21:        operator \*T* ();
        !            22:        unsigned size();
        !            23:        unsigned size(unsigned);
        !            24:        \*T* end();
        !            25:        void swap(const Block(\*T)&);
        !            26: }
        !            27: .ft R
        !            28: .fi
        !            29: .SH DESCRIPTION
        !            30: A
        !            31: .BI Block( T )
        !            32: is an array of zero or more
        !            33: .IR elements 
        !            34: of type
        !            35: .I T,
        !            36: where 
        !            37: .I T
        !            38: is a type name.
        !            39: .I T
        !            40: must have assignment
        !            41: .RB ( operator= )
        !            42: and initialization
        !            43: .RB ( \*T(\*T&) )
        !            44: operations.
        !            45: .PP
        !            46: The macro call
        !            47: .BI Blockdeclare( T )
        !            48: declares the class
        !            49: .BI Block( T ) .
        !            50: It must appear once in every source file that uses type
        !            51: .BI Block( T ) .
        !            52: The macro call
        !            53: .BI Blockimplement( T )
        !            54: defines the functions that implement the block class.
        !            55: It must appear exactly once in the entire program.
        !            56: .PP
        !            57: New elements 
        !            58: are initialized to the value of an otherwise
        !            59: uninitialized static object of type
        !            60: .I T.
        !            61: .SS Constructors
        !            62: .nr xx \w'\fLBlock(\fIT\fL)(\fIb\fL)'
        !            63: .TP \n(xxu
        !            64: .BI Block( T )
        !            65: An empty block.
        !            66: .TP
        !            67: .BI Block( T )( n )
        !            68: A block of
        !            69: .I n
        !            70: elements.
        !            71: .TP
        !            72: .BI Block( T )( b )
        !            73: A new block
        !            74: whose elements are copies of the elements of
        !            75: .BR b .
        !            76: .SS Operations
        !            77: Assignment copies elements and size.
        !            78: .TP \n(xxu
        !            79: .IB b [ k ]
        !            80: A reference to element
        !            81: .L k
        !            82: of block
        !            83: .IR b ;
        !            84: undefined if
        !            85: .I k
        !            86: is out of bounds.
        !            87: .TP
        !            88: .BI ( T *) b
        !            89: A pointer to the first element of block
        !            90: .I b.
        !            91: .SS Other functions
        !            92: .TP \n(xxu
        !            93: .IB b .size()
        !            94: Return the number of elements in
        !            95: .I b.
        !            96: .TP
        !            97: .IB b .size( n )
        !            98: Set the size of 
        !            99: .I b
        !           100: to
        !           101: .LR n .
        !           102: If the new size is greater than the old.
        !           103: Otherwise, 
        !           104: .I n
        !           105: old elements are kept.
        !           106: Return the new size.
        !           107: .TP
        !           108: .IB b .reserve( n )
        !           109: The size of
        !           110: .I b
        !           111: is increased, if necessary, to some value greater than 
        !           112: .I n.
        !           113: If
        !           114: .I b
        !           115: already has room,
        !           116: .I b
        !           117: is not changed.
        !           118: Return zero if memory could not be allocated
        !           119: and non-zero otherwise.
        !           120: .TP
        !           121: .IB b .end()
        !           122: Returns
        !           123: a pointer to just past the last element in
        !           124: .LR b .
        !           125: Equivalent to 
        !           126: .BR (T*)b+b.size() .
        !           127: .TP
        !           128: .IB a .swap( b )
        !           129: The memory associated with blocks
        !           130: .I a
        !           131: and
        !           132: .I b
        !           133: is exchanged.
        !           134: .SS Performance
        !           135: Most operations
        !           136: are implemented by the obvious uses of the
        !           137: .L new
        !           138: and
        !           139: .L delete
        !           140: operators.
        !           141: .I Reserve
        !           142: checks the size inline.
        !           143: If it isn't big enough, the size is increased by multiplying by 3/2
        !           144: (and adding one) enough times to increase it beyond
        !           145: .I n .
        !           146: .SH EXAMPLES
        !           147: .EX
        !           148: Blockdeclare(long)
        !           149: unsigned n = 0;
        !           150: Block(long) b;
        !           151: long x;
        !           152: while (cin >> x) {
        !           153:        b.reserve(n);
        !           154:        b[n++] = x;
        !           155: }
        !           156: .EE
        !           157: .SH SEE ALSO
        !           158: .IR malloc (3),
        !           159: .IR map (3)
        !           160: .SH DIAGNOSTICS
        !           161: The only error detected is running out of memory;
        !           162: this is indicated in all cases by setting the size of the
        !           163: block for which allocation failed to zero.
        !           164: .SH BUGS
        !           165: Elements are copied during reallocation by using
        !           166: .L T::operator=
        !           167: instead of
        !           168: .LR T(T&) .
        !           169: .br
        !           170: Because the `type parameter'
        !           171: .I T
        !           172: is implemented by the C preprocessor, white space is
        !           173: forbidden inside the parentheses of
        !           174: .BI Block( T ) .
        !           175: 

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