CS : APP  && Lab 0

                   之前在网上找了一会关于这几个实验的资料，发现都没有.其实washington university的<CSE351: The Hardware/Software Interface> 的课程实验. 

           伟大而又乐于分享的高校.WU

          我陆续更新把这五个实验(这个预热的lab0不算,太简单，C入门的级别,这里指lab1~lab5),贴出来分析学习.希望更多的人能够收益. 开源，分享.

--------------------------------------------------------------------实验要求--------------------------------------------------------------------

Editing, compiling, and running the code

                  Now that you have acquired the source file, open arrays.c in your favorite text editor. arrays.c file contains a number of TODOs, which you are expected to complete. Most have a proceeding line that says "Answer:", which is where you should leave an answer to the question(s) posed in the TODO. One TODO requires you to write some code, which you should place immediately after the comment block that describes what to do.
The source file arrays.c won‘t do you any good by itself; you need a compiler (specifically the GNU C compiler) to compile it to an executable format. The GNU C compiler is available on attu, the instructional Linux machines, the CSE home VM (https://www.cs.washington.edu/lab/software/homeVMs/) , and most popular variants of Linux, such as Ubuntu and Fedora. You‘re free to use whichever machine you like, although we will only provide support for attu, the instructional Linux machines, and the CSE home VM.

--------------------------------------------------------------------------------------------------------------------------------------------------------

lab0要求的arrays.c如下

/*
  CSE 351 Lab 0
  Lecture 2 and the first section meeting will help you
  if none of this makes sense yet.
*/


// These #includes tell the compiler to include the named
// header files, similar to imports in Java. The code for
// these is generally located under /usr/include/, such
// as /usr/include/assert.h. assert.h contains the
// declaration of the assert() function, stdio.h contains
// the declaration of the printf() function, and stdlib.h
// contains the declaration of the malloc() and free()
// functions, all of which are used in the code below.
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

// Fill the given array with values. Note that C doesn't
// keep track of the length of arrays, so we have to
// specify it as an explicit parameter here, rather than
// looking it up from the array as in Java.
// Additionally, note that the type of the array parameter
// here is int*, a pointer to an int. We'll learn more
// about why int* is used here, but for now it is enough
// to understand that array is an array of ints.
void fillArray(int* array, int len) {
  printf("Filling an array at address %p with %d "
         "values\n", array, len);
  for (int i = 0; i < len; ++i) {
    array[i] = i * 3 + 2;
    // assert() verifies that the given condition is true
    // and exits the program otherwise. This is just a
    // "sanity check" to make sure that the line of code
    // above is doing what we intend.
    assert(array[i] == i * 3 + 2);
  }
  printf("Done!\n");
}

// Structs are blocks of memory composed of smaller parts,
// each of which has a name and is called a field.  The
// following struct definition has four int fields named
// a, b, c, and d.
// In this case, we use typedef to give structs of this
// type a name, FourInts, which can be used like we use
// other types such as int or char.
typedef struct {
  int a, b, c, d;
} FourInts;

// main() is the entry point of the program. It has two
// parameters: argc is the number of arguments that were
// passed on the command line; argv is an array of those
// arguments as strings.  (Strings in C are arrays of
// chars.)
int main(int argc, char* argv[]) {
  // Create a new array capable of storing 10 elements
  // and fill it with values using the function declared
  // above. Arrays declared in this manner are allocated on
  // the stack, and must generally have a size (10, here)
  // that is a constant (i.e., the size is known when
  // writing the program, not computed when running it).
  int array[10];
  // This is a block of memory big enough to store 10
  // ints.  The name "array" here actually refers to the
  // address of this block of memory.
  // array[0] is the first int in this block of
  // memory, array[1] is the second, and so on. C does
  // not track or check array lengths, so it is up to us
  // to know how many elements the array contains.
  //
  // TODO(1): What happens if the second argument is set
  // to 11 instead? How about 100? 1000? Make sure to set
  // the second argument back to 10 when you are done
  // testing.
  // Answer:
  fillArray(array, 10);

  int value;
  // In C, we can take the address of something using the
  // & operator. &value is of the type int*, meaning that
  // it is a pointer to an integer (as it stores the
  // address in memory of where the actual int is located).
  //
  // TODO(2): We can actually use the address of the value
  // declared here as if it were an array of a single
  // element; why is this possible?
  // Answer:
  fillArray(&value, 1);
  // fillArray should set value to 0 * 3 + 2 = 2.
  assert(value =http://www.mamicode.com/= 2);>

Jason Leaster 给出的解答(由于是本人自己给出的解，如有錯漏望慷慨指出):
/*
  CSE 351 Lab 0
  Lecture 2 and the first section meeting will help you
  if none of this makes sense yet.
*/

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

void fillArray(int* array, int len) {
  printf("Filling an array at address %p with %d "
         "values\n", array, len);
  for (int i = 0; i < len; ++i) {
    array[i] = i * 3 + 2;
    assert(array[i] == i * 3 + 2);
  }
  printf("Done!\n");
}

typedef struct {
  int a, b, c, d;
} FourInts;

int main(int argc, char* argv[]) {
 
  int array[10];
 
  // TODO(1): What happens if the second argument is set
  // to 11 instead? How about 100? 1000? Make sure to set
  // the second argument back to 10 when you are done
  // testing.

 /* Answer by Jason Leaster:
			This problem's purpose is to guide
	you to understand what is "stack". You may have to
	understand code on running-time at level of assembly.
	Here is my notes,	
	-------------------------------------------------------
	http://blog.csdn.net/cinmyheart/article/details/24483461 

	http://blog.csdn.net/cinmyheart/article/details/39142471
	-------------------------------------------------------
	finish it and it will help you to get a background to
	understand this problem.

	If you set the second argument to "11" instead, the 
	program work well in 64-bits Ubuntu. But if you set
	the second parameter bigger than 12 (like 13,18,1000),
	you would destroy the %rbp register's value in this
	program and you will see "core dump" when you run it.

  */
  fillArray(array, 10);

  int value;
  //
  // TODO(2): We can actually use the address of the value
  // declared here as if it were an array of a single
  // element; why is this possible?

  /* Answer by Jason Leaster:         
			
			For this problem, what I want to
	say is that "God save me, it just a feature of C".
  */
  fillArray(&value, 1);
  assert(value =http://www.mamicode.com/= 2);>




valgrind 倒是个好东西~






CSAPP 六个重要实验    lab0(预热乱暖场 \-0-/ )