const - moodlearn.ariel.ac.il · Compare to Java’s “final” • All (methods as well as data )...

1

const

C’s “const”

C’s “const” is a qualifier that can be applied to the

declaration of any variable to specify its value will

not be changed.

C’s “const”

Examples:

const double E = 2.71828; E= 3.14; // compile error!

const int arr[] = {1,2}; arr[0] = 1; // compile error!

C’s “const”

• C’s “const” can be cast away

• Helps to find errors.

• Doesn't protect from evil changes !

const int arr[] = {1,2};

int* arr_ptr = (int*)arr;

arr_ptr[0] = 3; // compile ok!

// but might give a run-time error

Const and Pointer’s Syntax

Const protects his left side, unless there is

nothing to his left and only then it protects his

right side (examples next slide).

Const and Pointer’s Syntax

// Both, cannot change the int pointed by p

// using p

const int * p = arr;

int const * p = arr;

// Cannot change the address stored in p

int * const p = arr;

// Cannot change the address stored in p

// and the int pointed by p using p

int const * const p = arr;

Const and Pointer’s Syntax

// Both, cannot change the int pointed by p

// using p

const int * p = arr;

int const * p = arr;

// Cannot change the address stored in p

int * const p = arr;

// Cannot change the address stored in p

// and the int pointed by p using p

int const * const p = arr;

Very Useful

Never saw it

being used

C’s “const”

Do not confuse what the “const” declaration “protects”!

A pointer to a const variable:

A const pointer to a variable:

ptr value ``

ptr value ``

int arr[] = {1,2,3};

int const * p = arr;

p[1] = 1; // illegal!

*(p+1) = 1; // illegal!

p = NULL; // legal

int arr[] = {1,2,3};

int* const const_p = arr;

const_p[1] = 0; // legal!

const_p = NULL; // illegal!

C’s “const”

How about arr itself?

int arr[] = {1,2,3};

int* const const_p = arr;

const_p[1] = 0; // legal!

const_p = NULL; // illegal!

int *p;

arr=p; // compile error!

Const and User Defined Types

All the members of a const variable are immutable!

typedef struct Complex

{

int _real, _img;

int *_imgP;

} Complex;

Complex const COMP1 = comp2; // ok, init. using comp2

Complex const COMP3 = {3,2,&someInt}; // ok, copying values

COMP1._img = 3; // illegal!

COMP3._imgP = &someOtherInt; // illegal!

*(COMP3._imgP) = 5; // legal!

Compare to Java’s “final”

• All (methods as well as data ) are Class members.

• “final” makes primitive types constants and

references to objects constant.

• The values inside the referred final objects are not

necessarily constant !

final int LIMIT = 10; LIMIT = 11; // illegal! final MyObject obj1 = new MyObject(); MyObject obj2 = null; MyObject obj3 = new MyObject(); obj2 = obj1; // fine, both point now to the same object obj1 = obj3; // illegal! obj1.setSomeValue(5); // legal!

“Const” Usage

The const declaration can (and should!) be used in the definition of a function’s arguments, to indicate it would not change them:

Why use? (This is not a recommendation but a must) clearer code

avoids errors

part of the interfaces you define!

can be used with const objects

More of “const” meaning and usage in C++

int strlen(const char []);

13

C Strings

Strings

Java:

Char: is 2 bytes (Unicode)

String: an object which behaves as a primitive type (an

immutable object, passed by value)

C:

char: usually 1 byte. An Integer.

string: an array of characters.

t x e t Addr. `

`

char* txt1 = "text";

char txt2[] = "text";

char txt3[] =

{’t’,’e’,’x’,’t’,’\0’};

14

C Strings

Strings are always terminated by a null character, (a

character with integer value 0).

There is no way to enforce it automatically when you

create your own strings, so:

remember it’s there

allocate memory for it

specify it when you initialize char by char

char* text = "string";

// means text[5] = g and text[6] = \0

// 7 chars are allocated!

15

C string literals ("")

When working with char*, C string literals ("") are written

in the code segment (part) of the memory.

Thus, you can't change them!

C string literals ("")

When working with char*, C string literals ("") are written

in the code segment (part) of the memory.

Thus, you can't change them!

char* msg = "text";

msg[0] = ‘w’; // seg fault! – error caught only in runtime !

t x e t ``

Code part of memory Addr. msg

Stack

OS is protecting this area !

C string literals ("") with const

So, what we do is:

const char* msg = "text";

msg[0] = ‘t’; // compile error!

// better!

t x e t ``

Code part of memory Addr. msg

Stack

OS is protecting this area !

Difference between initialzing a pointer

and an array with C string literals ("")

char* msg = "text"; // msg is a pointer that points to a memory that is in the code part

char msg2[] = "text"; // msg2 is an array of chars that are on the stack

t

e

x

t

\0

t x e t ``

Code part of memory Addr. msg

Stack

Stack

char* msg = "text"; msg[0]= 'n'; // seg fault - trying to change what is written in the code part of the memory

char msg2[] = "text"; msg2[0]= 'n'; // ok - changing what is written in the stack part of the memory

Difference between initialzing a pointer

and an array with C string literals ("")

C Strings Examples

char txt1[] = "text"; char* txt2 = "text"; int i = strlen(txt1); // i = 4, same for strlen(txt2) txt1[0] = ’n’; // now txt1="next“ *txt2 = ’n’; // illegal! “text” is in the code // segment txt2 = txt1; // legal. now txt2 points to the // same string. txt1 = txt2; // illegal! if (! (strcmp(txt2,"next")) //This condition is now true { ...

21

C Strings Manipulation

To manipulate a single character use the functions

defined in ctype.h

Manipulation of Strings is done by including the string.h

header file

#include <ctype.h>

char c = ‘A’;

isalpha(c); isupper(c); islower(c); …

// copy a string

char* strcpy(char * dest, const char* src);

// append a string

char* strcat(char * dest, const char* src);

22

C Strings Manipulation (2)

NOTE : All C library functions assumes the usages of ‘\0’ and enough

storage space. No boundary checks! You are responsible. http://www.cplusplus.com/reference/cstring/

// compare two strings. // when str1 < str2 lexicographically return < 0 // when str1 > str2 lexicographically return > 0 // when identical return 0 int strcmp(const char * str1, const char* str2); // return strings length, not including the \0!! size_t strlen(const char * str); // Other functions: strncpy(),strncat(),strncmp() …

23

C Strings Functions

An “array” version of strcpy():

void strcpy(char * dest, const char* src) { int i = 0; while ((dest[i] = src[i])!= '\0')) i++; }

24

C Strings Functions

A “pointers” version of strcpy():

void strcpy(char * dest, const char* src) { while ((*dest = *src)!= '\0')) { dest++; src++; } }

25

C Strings Functions (2)

A shorter version::

Actually the comparison against \0 is redundant:

Style note: Unlike K&R book, we do NOT encourage

you to write such code. However, you should be able to

read and understand it.

void strcpy(char * dest,const char* src) { while ((*dest++ = *src++)!= '\0')); }

void strcpy(char * dest,const char* src) { while (*dest++ = *src++); }

26

How to duplicate a string?

27

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

int main()

{

const char *p1 = "hi mom",

*p2 = (char*)malloc(strlen(p1));

strcpy(p2,p1);

printf("%s\n",p2);

return 0;

}

How to duplicate a string?

28

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

int main()

{

const char *p1 = "hi mom",

*p2 = (char*)malloc(strlen(p1));

strcpy(p2,p1);

printf("%s\n",p2);

return 0;

}

How to duplicate a string?

29

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

int main()

{

const char *p1 = "hi mom",

*p2 = (char*)malloc(strlen(p1)+1);

strcpy(p2,p1);

printf("%s\n",p2);

return 0;

}

strdup: duplicate a string (part of the standard library)

30

char* strdup( char const *p )

{

int n = strlen(p);

char* q =(char*)malloc(sizeof(char)*(n+1));

if( q != NULL )

{

strcpy( q, p );

}

return q;

}

Memory Management

void

foo( char const* p )

{

char *q;

q = strdup( p );

// do something with q

}

The allocated memory remains in use

cannot be reused later on

p

q

<call> …

Heap

‘a’

‘b’

‘\0’

32

Memory Management

void

foo( char const* p )

{

char *q = strdup( p );

// do something with q

free(q);

}

Now the memory is being freed.