Topic 5: Revision of C Fundamentals

Synopsis

• Why Revise C
   
• Structs
   
• Struct field access
   
• Function prototypes
   
• File-based modularity^¤
   
• Static variables and functions
   
• Function pointers
   
• Function pointers and polymorphism^¤
   
• Reading
   

Why Revise C

• C is the basis of C++
   
• I'll assume you know this stuff
   
• Some of it you may never have seen!
   

 

Structs

• Struct definitions define a new record type
   
• Aggregration of fields of various types into a single record
   
• Need a typedef to avoid endless repetitions of the struct keyword

struct StudRec
{
	char*  name;
	int    idNum;
	double mark;
};

typedef struct StudRec Student;

Student  stud1;
Student* studptr;

Struct field access

• Access to the fields of a struct depends on whether we have a pointer to the struct object (e.g. studptr) or direct access to the object itself (e.g. stud1)
   
• Direct access via '.' operator:
  stud1.mark,
  stud1.name,
  etc.
   
• Access through pointer via '->' operator:
  studptr->mark,
  studptr->name,
  etc.
   

Function prototypes

• Function prototypes declare the name, arguments and return type of a function (i.e. its signature^¤!), but don't define its body:

int max_int(int,int); 
float max_float(float,float);

void LOI_Next(ListOfint*);

• Parameter names may be present or omitted (makes no difference)
   
• Empty parameter list (not void!) is special. It means "any parameters you like":

int f();    	/* f(); f(1); f(stud1); ETC. ALL OKAY */
int g(void);	/* ONLY g() ALLOWED */

• In other words, functions are weakly typed

File-based modularity^¤

• We typically structure a module (say for handling lists) as a "header file" (.h) and an associated "code file" (.c)
   
• Header file is included wherever functionality is required;

#include "list.h"

• Code file is compiled (once!) and linked into executable

> cc -c list.c

> cc main.c list.o sort.o pray.o -o progname

Static variables and functions

• Statically-declared variables and functions are only visible inside the current file
   
• Accessible to all other functions in the same file, but not elsewhere
   
• A form of encapsulation^¤
   
• For example:

static int studCounter = 0;

static Student* allocateStudent(void)
{
	return (Student*)malloc(sizeof(Student));
}

Student* newStudent(char* name, int idNum)
{
	Student* s = allocateStudent();
	strcpy(s->name,name);
	s->idNum = idNum;
	s->mark  = -1.0;
	studCounter++;
	return s;
}

void deleteStudent(Student* sptr)
{
	studCounter--;
	free sptr;
}

int studentCount(void)
{
	return studCounter;
}

Function pointers

• Like data, code is stored somewhere in the memory (RAM)
   
• Like data, we can find out where in memory a function is stored (the '&' operator)
   
• We can store this address in a function pointer and later call the function through that pointer
   
• To declare a function pointer: retType (*ptrname)(params);
   
• To call a function through a function pointer: (*ptrname)(args);
   
• For example:

int winner(int bet, int bank)
{
	printf("You're a winner! You made $%d\n", 2*bet);
	return bank + 2*bet;
}
 
int loser(int bet, int bank)
{
	printf("Better luck next time. You lost $%d\n", bet);
	return bank - bet;
}

typedef int (*BettingFunc)(int,int);

BettingFunc selectfunc(void)
{
	int randVal =  randIn(1,1000000);
	if (randVal==42) { return &winner; }
	else		 { return &loser; }
}

int main(void)
{
	int credit = 100;

	while (credit>0)
	{
		BettingFunc func;
		int bet;

		func = selectFunc();

		printf("Place your bet: ");
		scanf("%d", &bet);

		credit = (*func)(bet,credit);
	}

	printf("Thank-you for contributing to");
	printf("Victoria's $700 million surplus!\n");
}

Function pointers and polymorphism^¤

• Note that in the betting example, the behaviour^¤ of the function call:
  credit = (*func)(bet,credit);
  depended at run-time on which function func was pointing to
   
• That's polymorphism^¤
   
• If we needed to change the functions (or the odds), we could still use the same main (wouldn't even have to recompile it if it was in a separate file!):

int bigwinner(int bet, int bank)
{
	printf("You're a big winner! You made $1,000,000");
	return bank + 1000000;
}

int winner(int bet, int bank)
{
	printf("You're a winner! You made $%d\n", 2*bet);
	return bank + 2*bet;
}

int loser(int bet, int bank)
{
	printf("Better luck next time. You lost $%d\n", bet);
	return bank - bet;
}

int bigloser(int bet, int bank)
{
	printf("Bad luck! We now own your children\n");
	return bank - 1000000;
}

typedef int (*BettingFunc)(int,int);

BettingFunc selectfunc(void)
{
	int randVal =  randIn(1,1000000);
	switch (randVal)
	{
		case 42:  return &bigwinner;

		case 666: return &bigloser;

		default:
			if (randVal%4==0) { return &winner; }
			else		  { return &loser; }
	}
}

int main(void)
{
	int credit = 100;

	while (credit>0)
	{
		BettingFunc func;
		int bet;

		func = selectFunc();

		printf("Place your bet: ");
		scanf("%d", &bet);

		credit = (*func)(bet,credit);
	}

	printf("Thank-you for contributing to");
	printf("Victoria's $700 million surplus!\n");
}

Reading

• Lippman & Lajoie

Some new, some revision: Sections 3.5 to 3.15 and 7.5 to 7.9, Chapter 8.


 

• Stroustrup

Some new, some revision: Chapters 4 and 5.