From Java to C A Supplement to Computer Algorithms, Third Edition. Sara Baase Allen Van Gelder

Transcription

1 From Java to C A Supplement to Computer Alorithms, Third Edition Sara Baase Allen Van Gelder October 30, 2004

2 ii clcopyriht 2000, 2001 Sara Baase and Allen Van Gelder. All rihts reserved. This document may be copied reely or noncommercial purposes.

3 1 OVERVIEW This is a brie uide or convertin the subset o Java used in the text into C. The purpose is to help readers who want to implement some alorithms, but preer to work in C. Alternatively, i a prototype Java implementation has been developed and debued, readers miht wish to convert the proram to C to improve its perormance. Java has many constructs and eatures that the text does not use, and we do not address their conversion into C. Familiarity with C is a prerequisite or readin this uide. For excellent treatments o the C lanuae, see Gehani (1998) and Roberts (1995). This uide uses the terminoloy o declare and deine as set orth by Gehani. On Unix systems, C library unctions are documented in the man paes ; or example, man print elicits the speciications or print. It will also help i Section 1.2, Chapter 2 and the appendix o the text have been looked over (InputLib is in the appendix). Reerences in this uide reer to the text. Here are some basic correspondences between Java and C. Java C public static void main(strin[] arv) int main(int arc, char* arv[]) arv.lenth arc arv[i] arv[i+1] (arv[0] holds the proram name.) System.in, System.out, System.err stdin, stdout, stderr print or println print or print DYNAMIC ALLOCATION: newbecomes calloc Thenew operatorin Java correspondsmost closely to calloc in C becausecalloc initializes the allocated memory to binary zeros; malloc may also be used. Note that p below is technically a pointer in C. However, aside rom the constructor call to calloc, p can and should be treated as an array. Java C int[] p = new int[n]; int* p = calloc(n, sizeo(int)); int plenth = n; p.lenth plenth p[i] p[i] ORGANIZER CLASSES BECOME STRUCTS In eneral, oranizer classes in Java (a term introduced in the text) should be structs in C. Pointers to such structs are not routinely needed, but arrays o structs are appropriate wherever arrays o an oranizer class would be used in Java. In C the assinment statement operates on structs, copyin the contents o the struct, not just a reerence to it, so the copy methods o Java oranizer classes are not needed in C. We illustrate the ideas by translatin the Date class in Section 1.2 o the text, Exercise 1.1, into C. typede struct /* no nested typedes in C */ int number; int isleap; /* no boolean type in C */ Year; typede struct Year year; int month; int day; Date; ::: Date ::: duedate, noticedate; noticedate = duedate; noticedate.day = duedate.day - 7;

4 2 Unlike the Java example in Section 1.2, the above assinments work as expected: Chanin noticedate.day does not also chane duedate.day because the previous assinment copied the contents o duedate, not a reerence to it. It is perectly proper or a unction to return a struct, and this is the recommended way or a unction to produce several outputs. Because certain common prorammin needs are much simpler to code with structs, we would not be surprised to see structs added to some uture version o Java, as an extension to the eiht built-in primitive types. ADT CLASSES Althouh oranizer classes should become structs, ADT classes in Java should almost always become pointer types in C. O course, the pointer type will point to some struct, but that struct will normally be hidden rom the ADT clients. The desin philosophy is explained in Chapter 2 o the text (see Fiure 2.1, e..). The separate compilation eature o C allows the privacy eatures o Java to be simulated to a limited extent. We ll walk throuh an example, usin the IntList ADT o Chapter 2. The eneral idea or a C implementation o an ADT is that the public declarations and deinitions o in a header ile, conventionally named IntList.h, while the private declarations and deinitions o in the ile IntList.c. Both IntList.c and the ADT client iles include IntList.h. A salient point is that the pointer type or the ADT is normally public (so appears in IntList.h), while the details o the struct to which it points are private (so appear in IntList.c). The name o the struct (its ta) is public, however. In line with the oreoin remarks, IntList.h will have a declaration like this near its beinnin: typede struct IntListStruct * IntList; This declares (names, but does not deine)astructnamedintliststruct and deines the type IntList to be a pointer to this type o struct, whatever it is. Now unction prototypes and lobal constants or the ADT may be declared in IntList.h. Notice that prototypes are very similar to the unction headers in Fiure 2.4 o the text, but the words public and static are absent. (The meanin o static in C is quite dierent rom its meanin in Java, and is discussed later in this uide.) int irst(intlist L); IntList rest(intlist L); IntList cons(int newelement, IntList oldlist); extern const IntList nil; A point that is not widely appreciated is that the keyword extern in the declaration o nil means that the type o nil is bein declared in this statement, but the actual deinition o nil is elsewhere, possibly in the same ile or compilation unit. In this example, IntList.c will include IntList.h and the above extern declaration, and it will also contain the statement that deines (reserves storae or) nil, which becomes a lobally accessible constant. This will be seen in a ew pararaphs. Finally, let us remark that all the documentation (javadoc) comments that appear in Fiure 2.4 o the text should appear in IntList.h (as opposed to IntList.c). The theme o ADT encapsulation and inormation hidin is that IntList.h contains the public interace inormation or the ADT clients, whereas IntList.c may well not be available to those clients (they would link in the separately compiled IntList.o). Now let us turn to the contents o IntList.c, whichimplements the ADT. Ater the customary #include statements, the irst order o business is to complete the declaration o IntListStruct. Then nil is deined. Aain, it is instructive to compare with Fiure 2.4 and observe the correspondences. #include #include <stdlib.h> "IntList.h" struct IntListStruct int element; IntList next; ; const IntList nil = NULL;

5 3 We miht also include the ollowin bizarre-lookin statement: typede struct IntListStruct IntListStruct; This makes IntListStruct a type as well as the name o a struct. It happens that the IntList ADT does not have a use or this type, but it miht be convenient in some more elaborate ADTs. Please reer to the C reerences cited in the overview or more inormation about this syntactic issue. The actual C code in the unction bodies is quite similar to Java (or the subset o Java used in the main part o the text). A very important dierence, however, is that pointer variables are ollowed by the arrow operator (->) in C, not the dot operator, to access instance ields o the object to which they point. Thus the C code will have L->element, L->next, etc. We include one example. IntList cons(int newelement, IntList oldlist) IntList newlist = calloc(1, sizeo(struct IntListStruct)); newlist->element = newelement; newlist->next = oldlist; return newlist; One o the advantaes o Java or lare projects that is not enjoyed by C is that unction names are qualiied when they are used outside their class. For example, i a proram has list ADTs o several types, in C it cannot use irst in all o them as a unction name. A common solution in C is to deine a two- or three-letter preix or each ADT and bein all public names with that preix. Even i name clashes are not a problem, it helps other prorammers to determine which unctions are in which ADTs, modules, or libraries. In translatin the IntList ADT to C, it miht be appropriate to rename irst, cons, and so on to somethin like il irst, il cons, andsoon. VISIBILITY OF FUNCTIONS AND DATA STRUCTURES Althouh we don t have an example o it in IntList, it oten happens that we want to deine a subroutine or data structure inside an ADT and have it not be visible to the outside world. I nothin else, havin every subroutine visible throuhout a lare proram invites name clashes and accidental misuse when a unction with a similar name was intended. The mechanism in C or limitin visibility to the unctions that comprise an ADT is to use the static keyword. This word is rather misleadin, but we are stuck with it in C. When static appears in ront o a declaration or deinition that would otherwise be lobally visible it directs the compiler and linker to make the name visible only in the current compilation unit or ile bein compiled. Thus by combinin static and separate compilation,a deree o privacy or an ADT can be achieved. The correspondences between Java and C are as ollows: 1. A nonpublic static Java method becomes a static C procedure. Its prototype appears in the.c ile, not in the.h ile, or the ADT. 2. A public static Java method becomes an extern (lobally visible) C procedure or unction. Its prototype appears in the.h ile and its body appears in the.c ile or the ADT. 3. A nonpublic static Java instance ield becomes a static C variable. Its deinition appears in the.c ile, not in the.h ile, or the ADT. 4. A public static Java instance ield becomes an extern C variable. Its declaration, with the keyword extern, appears in the.h ile and its deinition, without extern, appears in the.c ile or the ADT. I these technicalities seem too complicated, readers should remember that limitin visibility is not necessary or correct unctionin unless there are name clashes. In most moderate-sized prorams, name clashes can be avoided simply by usin unique names. READING INPUT C oers many perhaps too many ways o readin iles. Our purpose here is just to sketch the eatures o C that correspond to the method o readin input described in the appendix o the text, primarily in the class InputLib.

6 4 The C unctions involved are all thorouhly documented as part o the stdio and strin libraries. No special library need be deined in C by the prorammer. The ollowin includes should be near the beinnin o a C ile that processes input. We also typede Cstrin or convenience. #include <stdio.h> #include <stdlib.h> #include <strin.h> typede char * Cstrin; A ile pointer (type FILE *) is returned by open, and the standard ile pointer stdin is automatically available to a C proram. Other input unctions will use the ile pointer as a parameter to indicate which ile is to be processed. We will desinate the ile pointer by inbu in the examples. For example, close(inbu) closes a ile previously opened by open. The primary input unction is ets, which ets one complete line o input into a buer (a character array, previouslyallocated). It is the analooetline in InputLib. TheetLine calls in Fiure A.2 would translate somethin like this: char line[1024]; /* A enerous overestimate or any one line */ char* etsretn; ::: etsretn = ets(line, 1024, inbu); while (etsretn == line) Ede e = parseede(line); ::: etsretn = ets(line, 1024, inbu); i (! eo(inbu)) /* Some error occurred */ Note that ets will not overlow line even i the input line is more than 1023 characters, so it is sae in this sense. PARSING A LINE OF INPUT AND OTHER STRING OPERATIONS At this point we want to point out that objects in the Strin class in Java are immutable; their contents cannot be chaned. So each etline call in Java necessarily returns a new strin. However, in C ets writesintoanarray allocated by the caller, and typically this array is used repeatedly or this purpose, as in the example above. Most o the strin library unctions in C work in a similar ashion; the caller is expected to allocate the space or the result, then use a parameter o the call to inorm the strin unction where that space is. An exception is strdup, which allocates the needed space, and returns its address to the caller. The ollowin table summarizes some correspondences between Java and C. We will see additional details about strin library unctions later. Java p = InputLib.open(name); 1 line = InputLib.etLine(p); nexttoken Inteer.parseInt Double.parseDouble Strin s s.lenth() Strin s = s1 + s2 + s3 tostrin [1] Assumes name 6= "-". C p = open(name, "r"); lptr = ets(line, len, p); strtok or strtok r (see discussion) atoi ato char s[n const ] or char s[] or Cstrin s (see discussion) strlen(s) Cstrin s = calloc(len, sizeo(char)); strncpy(s, s1, len); strncat(s, s2, len - strlen(s)); strncat(s, s3, len - strlen(s)); sprint Since C does not allocate space or strins like Java, the prorammer needs to be sure that strin operations occur only within allocated space. The library unctions strcpy, strcat, ets, and many others are unsae because

7 5 they miht write beyond the bounds o allocated space. Their counterparts, strncpy, strncat, ets, include a lenth parameter to limit the number o characters the unction will write. That parameter miht be set to any value by the caller, but the sensible value is the number o bytes actually available in the allocated space or the taret strin. As in the Java version o parseede in the text appendix (see Fiure A.3), it is the job o the C version o parseede to et the data ields out o line. First, we typede Ede as a struct, in accordance with the earlier discussion o oranizer classes. typede struct int rom; int to; double weiht; Ede; Now we ive two versions o parseede. The irst version is much simpler, and uses the knowlede o what is expected in the input line. It uses sscan with parameters that are desined or the line to contain two inteers, possibly ollowed by a loatin-point number. The second version is more complicated, and uses the eneral unction strtok, to accommodate input strins o unknown ormat. parseede with sscanfirst, we ll ive the code, then explain it. Ede parseede(char line[]) Ede newe; int numfields; numfields = sscan(line, " %d %d %l %*s", &newe.rom, &newe.to, &newe.weiht); i (numfields < 2 numfields > 3) print("bad ede: %s", line); exit(1); i (numfields == 2) newe.weiht = 0.0; return newe; The sscan unction extracts data items rom the char array that is its irst parameter (line in our example). The extraction is overned by the pattern iven in the second parameter, which is usually an explicit strin enclosed in double quotes, as in our example. Remainin parameters are addresses at which to store the extracted data items; the & preix operator can be read address o. A ull explanation o the scan amily may be ound in the man paes o your Unix system, or in a book that describes the C library unctions. We conine our explanation to this example. The pattern strin or extraction includes a space to indicate where an arbitrary number o white space characters may occur. A ield in this strin beinnin with % speciies a data item to be extracted rom the input. The codes we use are %d to extract an int, %l toextracta double, and %s to extract a strin. But we actually speciy %*s to speciy that, althouh the strin is extracted, it is discarded. That is, there is no parameter in the sscan call that speciies a storae location or the strin. So the technique here is a trick to see i there is extra unexpected stu on the line that was read and passed into parseede. I sscan does ind any siniicant characters ater extractin three ields, it will return the value 4; this will lead to an error messae. We emphasize that a ield %s must correspond to a later parameter that ives the address o a char array in which to store a strin ound in line. The prorammer must ensure that adequate space has been allocated to store that strin. For most applications where the input is oranized by lines, the combination o ets and sscan provides a sae and adequate method to read and parse the input data.

8 6 parseede with strtokfirst, we ll ive the code, then explain it. Ede parseede(char line[]) Ede newe; Cstrin linetmp = strdup(line); Cstrin w1 = strtok(linetmp, " ntnn"); Cstrin w2 = strtok(null, " ntnn"); Cstrin w3 = strtok(null, " ntnn"); Cstrin w4 = strtok(null, " ntnn"); i (w1 == NULL w2 == NULL w4!= NULL) print("bad ede: %s", line); exit(1); newe.rom = atoi(w1); newe.to = atoi(w2); i (w3!= NULL) newe.weiht = ato(w3); else newe.weiht = 0.0; ree(linetmp); return newe; The nexttoken unction in Java translates enerally to the strtok unction in the C strin library. First we make anewcopyoline in linetmp because strtok will chane the contents o its irst arument. The irst call to strtok requests (the address o) the irst word or token in the Cstrin linetmp. Because linetmp 6= NULL, strtok remembers it and returns the address o the irst token. The second throuh ourth calls to strtok have NULL as the irst parameter, indicatin that the caller wants subsequent tokens rom the same Cstrin that it is rememberin, i.e., linetmp. The second parameter o strtok speciies a list o characters that are to be treated as delimiters or the token requested. In this case we speciied space, tab, and newline, a popular set o delimiters. Extra delimiters are discarded. For example, there miht be spaces beore the irst token. I no characters remain in linetmp or the only characters that have not been converted to tokens are delimiters, strtok returns NULL. Thus the irst i test in the code is true i linetmp contains ewer than two tokens or more than three tokens. The second i is true i there is a third token. Whenever strtok inds the requested token, it writes a binary zero character immediately ater the end o it in linetmp and returns the address within linetmp where the token beins. Thus the returned address is a pointer to a 0-terminated strin. We copied line into linetmp so line would remain intact. I we need to remember the strin returned by strtok or any lenth o time, we must make a sae copy o it with strdup. In the example, we use atoi and ato to interpret these tokens as ints and doubles, ater which we do not need them. As a rule, you want to process all tokens returned by strtok with one o the unctions strdup, atoi, orato, dependin on whether it is a strin, int, or double (doubles miht be converted to loats). Then linetmp can be saely reed so its space can be reused. Notice that it is not necessary to make a dynamic allocation o the struct newe in C; the return statement copies its contents back into the caller s storae area. Notice how this is dierent rom the construction o an ADT object, as illustrated in the example o IntList.c.