Direct Memory Access. Lecture 2 Pointer Revision Command Line Arguments. What happens when we use pointers. Same again with pictures

Transcription

1 Lecture 2 Pointer Revision Command Line Arguments Direct Memory Access C/C++ allows the programmer to obtain the value of the memory address where a variable lives. To do this we need to use a special variable type called a pointer. Pointers allow us to store the value of the memory address for a specific type of variable. To declare a variable as a pointer to a variable we use the * as follows 1 int i; 2 int *ptri; What happens when we use pointers Normally a variable directly contains a specific value A pointer contains the (memory) address of a variable that contains a specified value A variable name directly references a value and a pointer indirectly references a value Referencing a value through a pointer is called indirection Same again with pictures int *countptr int count 4 int count 4 count directly references a variable whose value is 4 countptr indirectly references a variable whose value is 4.

2 Simple Example What did that code do? 2 #include <cstdlib> 3 4 int main(void) 5 { 6 int i; 7 int *ptri; 8 i=5; 9 std::cout <<"I given the value 5 directly i="<<i<<std::endl; 10 ptri=&i; // ptri now points to i 11 *ptri=10; 12 std::cout <<"Now using the pointer ptri now equals "<<i <<std::endl; 13 std::cout <<"ptri = "<<ptri<<" *ptri = "<<*ptri<<std::endl; 14 return EXIT_SUCCESS; 15 } Firstly two variables are declared i a normal integer and *ptri which is a pointer The first assignment i=5 directly assigned i with the value 5. The second assignment ptri=&i says store the address of the variable i into the variable ptri The final assignment *ptri=10; tells the program to put the value 10 into the memory address pointed to by ptri confused?... Lets look at some pictures With Pictures With Pictures ptri=&i; *ptri=10; 0x100 0x100 i 0x102 i 10 0x102 0x104 0x104 ptri 0x102 0x106 ptri 0x102 0x106 0x108 0x108 0x10A 0x10A

3 char **data; Can any determine what char **data is representing? char ** It s a pointer to a pointer of char data 0x10 Some Text\n Think of it as char[][] *data 0x22 more data\n char **data 0x10 0x22 0xff 0x9f 0x1ff 0x2ff 0x3ff 0xff Text here\n 0x9f and here\n 0x1ff must be terminated by\n Memory 0x2ff and here \n 0x3ff \n Memory pass by value 1 int PassByValue(int a) 2 { 3 return a+10; 4 } Consider the function above When passing by value a temporary copy of the variable is made in memory taking up space and Once control returns to the calling procedure any changes to the variable will not be recognised, and you will still have the original variable. pass by Reference 1 void PassByRef(int &a) 2 { 3 a+=10; 4 } This essentially passes a pointer, but not the same kind of pointer you would get when using int *a; That is why it is called by reference, since that is what you have, a now acts as if it were the parameter just like in the by value way, but any changes affect the original variable passed in.

4 2 #include <cstdlib> 3 4 int PassByValue(int a); 5 void PassByRef(int &a); int main(void) 9 { 10 int value=10; std::cout<<passbyvalue(value)<<std::endl; 13 std::cout<<"value is "<<value<<std::endl; 14 PassByRef(value); 15 std::cout<<"value = "<<value<<std::endl; return EXIT_SUCCESS; 18 } int PassByValue(int a) 21 { 22 return a+10; 23 } void PassByRef(int &a) 26 { 27 a+=10; 28 } const In the original C++ design const was called readonly We shall see later in the year this is very useful when passing objects by reference As we can mark things as not being able to be modified but still having the advantage of pass by reference. This is a compile time check so no overhead in execution is encountered when doing this. We will be looking at this in more depth later in the course 2 #include <cstdlib> 3 4 void ConstParam(const int &a) 5 { 6 a+=10; 7 } int main() 11 { 12 int value=10; 13 ConstParam(value); return EXIT_SUCCESS; 16 } 1 g++ const.cpp 2 const.cpp: In function 'void ConstParam(const int&)': 3 const.cpp:6: error: assignment of read-only reference 'a' Command Line arguments When a program is executed from a command line it may be passed different parameters as arguments to the program. Many examples of this may be seen in the Unix operating system with standard commands. For example ls may be used on it's own or with different flags such as ls -al where the -al is a command line argument.

5 main() The main function is the entry point in any C / C++ program and may be declared in a number of ways as shown below 1 int main() 2 int main(int argc, char *argv[]) 3 int main(int argc, char **argv) The first version returns an integer value when the program has exited. Next two versions are the same main has two parameters, int argc and char *argv[]. These are the only parameters that main in allowed and are used in the following ways int argc is the argument count and passes the number of arguments passed at the command line. char * argv is a pointer to a list of command line arguments which may be accessed as if they were a series of strings. sample program 2 #include <cstdlib> 3 4 int main(int argc, char **argv) 5 { 6 for (int i=0; i<argc; ++i) 7 std::cout <<"argument #"<<i<<" value "<<argv[i]<<"\n"; 8 9 return EXIT_SUCCESS; 10 } 1 argument #0 value a.out 2 argument #1 value -a 3 argument #2 value -b 4 argument #3 value test 5 argument #4 value 1 6 argument #5 value 2 7 argument #6 value 3 Simple Example II You will notice that the first argument (argv[0]) prints out a.out. This is because the whole of the command line typed is passed into the program. When the program is executed the command line is parsed and each space separated command is placed into each argv array element. Finally the size of the argv array is placed into argc. Parsing Command Line args This process is not automatic, you have to decide upon the argument types and how they affect the program This is part of the program design process It is usually the first thing you do after main.

6 Exercise We need a program that can respond to the following flags -h :- print out help and exit -a :- add the character to the message string -d put program in debug mode How would we approach the design of this program? 1 #include <stdlib.h> 2 #include <iostream> 3 #include <string> 4 // cstring for c strcmp 5 #include <cstring> int main (int argc, char * argv[]) 9 { 10 int argcount=1; /* argv 1 is the first parameter */ 11 bool Debug=false; 12 std::string message; 13 while(argcount < argc ) 14 { 15 if(strcmp(argv[argcount],"-h") == 0) 16 { 17 std::cout << "You asked for Help \n Now exiting\n"; 18 exit(exit_failure); 19 } 20 else if(strcmp(argv[argcount],"-a") == 0) 21 { 22 std::cout <<"Adding "<<argv[++argcount]<<std::endl; 23 message +=argv[argcount]; 24 message +=" "; 25 ++argcount; 26 } 27 else if(strcmp(argv[argcount],"-d") == 0) 28 { 29 ++argcount; 30 Debug=true; 31 } 32 else 33 { 34 std::cout <<"unknown argument #"<<argcount++<<std::endl; 35 } 36 } // end of parse args std::cout <<"Ending program Debug mode "<<Debug<<std::endl; 39 std::cout <<"Message is \""<<message<<"\"\n"; 40 return EXIT_SUCCESS; 41 } 42 1 a.out -a hello -a main -a input -d 1 Adding hello 2 Adding main 3 Adding input 4 Ending program Debug mode 1 5 Message is "hello main input " C++ strings In the previous example we used the C++ string data type This is a class that allows use to store text data It has many built in functions to allow us to do comparisons and manipulations of text data In this example we use the += function to concatenate the strings together. We will see later that we can do comparisons using the == functions as well bool data type We also use the bool data type to represent boolean values it can be assigned to either true or false It is preferable to use this for any truth data values

7 getopt The simplest way to handle command line options is the getopt C library function. It is part of the standard unix library and versions are available for shell scripts and Python 1 #include <unistd.h> 2 3 extern char *optarg; 4 extern int optind; 5 extern int optopt; 6 extern int opterr; 7 extern int optreset; 8 9 int getopt(int argc, char * const argv[], const char *optstring); for more info type man 3 getopt in the console 2 #include <cstring> 3 #include <unistd.h> // for get opt 4 5 // a list of the arguments to look for 6 const char ARGUMENTS[]="vdhf:ab"; 7 8 int main (int argc, char * argv[]) 9 { 10 // the character returned from the getopt function 11 char c; 12 bool Debug=false; while( (c=getopt(argc,argv,arguments))!=eof) 15 { 16 switch(c) // which option has been chosen 17 { 18 case 'h' : // -h 19 std::cout<< "You asked for Help \n Now exiting\n"; 20 exit(exit_failure); 21 break; case 'f' : // -f 24 std::cout <<"Passing the File flag the filename is "<<optarg<<std::endl; 25 break; case 'd' : 28 Debugˆ=true; 29 break; 30 case 'a' : 31 std::cout <<"-a called\n"; 32 break; case 'b' : 35 std::cout <<"-b called\n"; 36 break; case '?' : // unknown option report this and exit 39 std::cout<<"unknown argument "<<optopt<<std::endl; 40 std::cout<<"valid arguments are -d -h -f [name]\n"; 41 std::cout<<"will now exit\n"; 42 exit(exit_failure); 43 break; }// end switch 46 } // end of parse args std::cout << "Ending program Debug mode = "<<Debug<<std::endl; return EXIT_SUCCESS; 51 } Environment Variables Environment List As well as command line arguments every C / C++ program is also passed an environment list. Like the argument list. the environment list is an array of character pointers, with each pointer containing the address of a null terminated C string. The address of the array of pointers is contained in the global variable environ defined as environment pointer environ: environment list NULL environment strings HOME=/home/jmacey\0 PATH=:/bin:/usr/bin\0 SHELL=/usr/bin/bash\0 USER=macey\0 LOGNAME=macey\0 1 extern char **environ;

8 getenv 2 #include <unistd.h> 3 #include <cstdlib> 4 5 int main(int argc, char *argv[] ) 6 { 7 char *Env; 8 if(argc <= 1) 9 { 10 std::cerr<<"usage : env VARIABLE\n"; 11 exit(exit_failure); 12 } 13 Env=getenv(argv[1]); if(env!=null) 16 std::cout<<argv[1]<<"="<<env<<std::endl; 17 else 18 std::cout<<"variable "<<argv[1]<<" does not exist\n"; 19 return EXIT_SUCCESS; }