Lecture 09: C-Strings

This is probably a good place to use a global constant

An array of chars is not a C-string until it has a null terminator

C-string shorthand

• C++ has a shorthand for initializing C-strings:

  char vowels[] = "aeiou";
  

• The null terminator is automatically added
• The length is one more than the number of characters
• What happens in the following initializations?

  char a_ch = 'a';
  char a_str[] = "a";
  char greeting[32] = "Hello!";
  char hello[6] = "Hello!";
  

Some C-string gotchas

• Initializing with a string literal is a shorthand - the following are identical:

  char message[] = "Hello!";
  char message2[] = {'H', 'e', 'l', 'l', 'o', '!', '\0'};
  

• This means that you cannot reassign a C-string, just as you can only use the curly bracket syntax when initializing an array

• You can reassign individual characters:

  char message[] = "Hello!";
  message[0] = 'G';
  

• Don’t forget to allocate enough space for the null terminator!

C-string I/O

• Output is easy, we’ve been doing it all semester:

  cout << "This is a C-string" << endl;
  char message[] = "This is also a C-string";
  cout << message << endl;
  

• Input is a bit more complicated:

  char name[32]; // need to guess a size!
  cout << "Enter your name: ";
  cin >> name;
  

• Recall: what does cin do when it encounters whitespace?

The getline function

• All input streams (such as cin) have a getline member function

  cin.getline(buffer, size, [delimiter]); // optional third argument
  

• This reads up to size - 1 characters, or until the is encountered
• Default delimiter is the newline character
• The “buffer” is just a C-string that you provide

  const int MAX_NAME = 32;
  char name[MAX_NAME];
  cin.getline(name, MAX_NAME);
  

get vs. getline

• There’s also cin.get(buffer, size, delimiter)
• They’re almost the same, but get leaves the delimiter character in the buffer and getline consumes (and discards) it
• Both do not ignore leading whitespace (unlike cin >> var)
• If you need to skip over whitespace, there are a couple of options:
  • cin.ignore(n) to ignore the next n characters
  • cin >> ws to ignore all leading whitespace (my preference)

C-Strings plus functions

• We can pass C-strings to functions just like any other array
• Since a C-string always has a null terminator, we don’t need to pass the size
• Example: write a function to calculate the length of a string

  int len(const char str[]) {
      int length = 0;
      while (str[length] != '\0') {
          length++;
      }
      return length;
  }
  

• This is so common that C++ provides a function strlen in <cstring>

More <cstring> functions

• The <cstring> header provides useful functions for C-strings
• Some common ones are:
  • strlen(str): returns the length of a C-string
  • strcpy(dest, src): copies one C-string to another
  • strcat(dest, src): concatenates two C-strings
  • strcmp(str1, str2): compares two C-strings
• Caution: these functions do not check buffer size! For example, the following has undefined behaviour and will make your program behave strangely:

  char name[4];
  strcpy(name, "Charlotte Curtis");
  

Example: Hello World the complicated way

hello = "Hello"
world = "World"

message = hello + " " + world + "!"
print(message)

char hello[] = "Hello";
char world[] = "World";

char message[32];
strcpy(message, hello);
strcat(message, " "); 
strcat(message, world);
strcat(message, "!");

cout << message << endl;

strcmp behaviour

For the function call strcmp(str1, str2), the return value is:

• 0 if str1 and str2 are equal (max length does not matter!)
• -1 if str1 comes before str2 alphabetically
• 1 if str1 comes after str2 alphabetically

char fruit[];
cout << "What kind of fruit would you like? ";
cin >> fruit;

if (strcmp("apple", fruit) == 0) {
    cout << "Great choice, you can make pie!" << endl;
}

What about the string class?

• C++ provides a much more user-friendly string type
• You will encounter this in various tutorials, but for now, I want you to learn the pain of working with C-strings
• You will need C-strings and the getline function for Assignment 2
• Do not use the string class for Assignment 2!

Separate Compilation

• Typical lab structure:
  • lab.h
  • lab.cpp - #include "lab.h"
  • main.cpp - #include "lab.h"
• Prevents duplication of the code in lab.h, keeps main logic clear
• We could compile in multiple steps:
  • g++ -c lab.cpp - compiles lab.cpp into lab.o
  • g++ -c main.cpp - compiles main.cpp into main.o
  • g++ -o main main.o lab.o - links the two object files

What happens when you run make?

Compiling in multiple steps is annoying, so we dump it in a makefile

# This is "Makefile". Notice that comments begin with "#"
program: lab.o main.o
    g++ main.o lab.o –o program
main.o: main.cpp
    g++ -c main.cpp
lab.o: lab.cpp
    g++ -c lab.cpp

• Important: the indentation is a tab, not spaces! (emacs knows this)

Protecting against multiple #includes

• Most projects have many different modules (a somewhat random example )
• For example, in assignment 2 (not yet released):
  • main.cpp includes applicant.h and score.h
  • score.h includes applicant.h
• Problem: #include means “copy and paste” so we’re defining stuff twice!
• Solution: header guards
  • Wrap your header file in #ifndef and #endif directives

Header guards

#ifndef APPLICANT_H
#define APPLICANT_H

... // contents of applicant.h

#endif // APPLICANT_H

• #ifndef checks if the macro APPLICANT_H is defined
• If it is, the preprocessor skips to the #endif
• By convention, the macro name is the header file name in all caps
• Also conventional to put a comment after the #endif

Separate Compilation check-in 1/2

Which of the following are good reasons to use separate compilation? Select all that apply.

Separate Compilation check-in 2/2

The #include directive is a preprocessor directive that means:

Coming up next

• Lab: C-strings
• Next lecture: Structures
• Assignment 1 due TOMORROW!
• Assignment 2 available next week: Arrays, C-strings, and structures

Textbook Chapter 10