Yamyam: 1版をインポートしました

2018-06-28T17:51:53Z

1版をインポートしました

wiki>Adc: Minor code fixes.

2012-04-27T21:03:51Z

Minor code fixes.

新規ページ

= C Data Structures and Pointers=

_".... you need to learn about data structures. These are things like those lists that keep keep showing up in Blender."_ --stiv

=== Defining Structures===
Structures are typically collections of variables and such that we want to
keep together. A simple example would be found in source/blender/makesdna/
DNA_meshdata_types.h. Scrolling down to line 67 we see the following code:

<source lang="cpp">
typedef struct MCol {
char a, r, g, b;
} MCol;
</source>
We have declared a structure type called MCol. Inside this struct we have
variables or structure members. In this case there are four variables of type
char, one each for alpha, red, green, and blue. The [[DeveloperWiki/MCol|MCol]] after "}" means we
just created an instance of [[DeveloperWiki/MCol|MCol]] called MCol. This last [[DeveloperWiki/MCol|MCol]] is a variable
which every time we use it we can get its alpha, red, green, and blue structure
variables.

One thing of note is the typedef statement. Without it every time we wanted to
create a new structure variable we would have to do this:
<source lang="cpp">
struct MCol MYCol;
</source>
Which would create a structure variable named [[DeveloperWiki/MYCol|MYCol]] of type MCol. To simplify
we use typedef and save some typing like so:
<source lang="cpp">
MCol MYCol;
</source>
This is a bit of a simple explanation of typedef and there are other uses for it.

=== Assigning Structure Members===

So now we have this structure and it had structure members. How do we get the
data of these members in and out of the structure? Well, there are a couple of
ways. The first way is to assign the structure members when declaring the
structure like so:
<source lang="cpp">
typedef struct MCol {
char a, r, g, b;
} MCol = { 255, 0, 128, 255 };
</source>
This would assign a=255, r=0, g=128, and b=255 to the variables in the struct.

Option two:
<source lang="cpp">
typedef struct MCol {
char a, r, g, b;
} MCol;

MCol MCol = { 255, 0, 128, 255 };
</source>
Notice this time we assign the member variables and structure variable separate from
the structure declaration.

And finally after declaring a structure we can assign values to members by using
this syntax:
<source lang="cpp">
MCol.a = 255;
MCol.r = 0;
MCol.g = 128;
MCol.b = 255;
</source>

=== Structure Code Example===

<source lang="cpp">
/* Code listing for BabyBlend */

#include <stdio.h>

int main(void) {
/* declare structure */
typedef struct MVert {
float co[3]; /* array for vertex coordinates */
short no[3]; /* array for vertex normals */
char flag, mat_nr; /* variables for a flag and material index */
} MVert;

/* create variable of type MVert */
MVert vert;
char key_press = '\0';

printf("\nWelcome to BabyBlender\n\n");
printf("To create a vertex press 'V'\n");
printf("Key: ");
scanf("%c", &key_press);
switch (key_press) {
case 'V':
case 'v':
/* assign values to the structure's array */
printf("Enter X coordinate: ");
scanf("%f", &vert.co[0]);
printf("Enter Y coordinate: ");
scanf("%f", &vert.co[1]);
printf("Enter Z coordinate: ");
scanf("%f", &vert.co[2]);

/* print the values from the structure's array */
printf("\nYour vertex is is located at\n");
printf("X: %f\n", vert.co[0]);
printf("Y: %f\n", vert.co[1]);
printf("Z: %f\n", vert.co[2]);
break;
default: printf("That is not an option\n");
}
}
</source>
So structures are not that scary after all.

=== Pointers and Variables===

_"I'd recommend that anyone who's planning to dig through the source acquaint themselves intimately with C's use of pointers, including the ways that you access elements of pointers to structures; as well as building and incrementing through linked lists; and function pointers."_ --harkyman

A pointer is a variable that holds an address in memory.

A variable can hold data of different types and sizes. Lets say that I
wanted to store the alpha, red, green, and blue values of a vetrice in memory
using integers. Integers take up two bytes so the following would use 8 bytes:

<source lang="cpp">
int a = 255;
int r, g, b;
r = 0;
g = 128;
b = 250;
</source>

=== Declaring Pointers===
When creating a pointer you declare it to be a specific type. This type
helps tell how much memory is needed. To declare a pointer variable declare the
type followed by the variable name with an asterisk prefix like so:
<source lang="cpp">
int *alpha;
int *red, *green, *blue;
</source>

There are four pointers which hold the address of our variables. At each
address we can store an integer. This is where is gets good. We want to store
the address of each variable to the pointers. We use the ampersand as a prefix
to the variable name when assigning it to a pointer.

<source lang="cpp">
alpha = &a;
red = &r;
green = &g;
blue = &b;
</source>

=== Using Pointers===
Pointers are used in a number of ways.
<source lang="text">
&alpha is used for the address of the pointer.
alpha is used for the address held by pointer.
*alpha is used for the value held at the address stored in the pointer.
</source>
Nice stuff. Just remember there is a difference between variables and pointers.
When adding one to a variable we add to the value stored in the variable. When
adding one to the pointer, we add to the address of the pointer. So if our color
pointers are all in order in memory, by adding one to the pointer alpha I would get
the address of red.
<source lang="cpp">
alpha +=1;
</source>
If I add four to alpha I would get the address of the next alpha. This is
because a pointer of type integer can only hold the address of an integer. In
addition to this the pointer also knows that it is 2 bytes long. To add one to the variable b
using a pointer:
<source lang="cpp">
*blue += 1;
</source>
Now blue is 251. This is pretty powerful stuff.

=== Pointer Code Example===
<source lang="cpp">
/* code listing for BabyBlend2 */

#include <stdio.h>

int main(void) {
/* declare some variables of type int*/
int a, r, g, b;
/* declare pointers to type int */
int *alpha, *red, *green, *blue;
/* assign the addresses of the variables to the pointers */
alpha = &a; red = &r; green = &g; blue = &b;
/* assign values to the variables using pointers */
*alpha = 255;
*red = 0;
*green = 128;
*blue = 250;

/* print alpha data */
printf("\nAddress of pointer alpha %p\n", &alpha);
printf("Address held by pointer alpha %p\n", alpha);
printf("Value at address held by alpha %d\n", *alpha);

/* print red data */
printf("\nAddress of pointer red %p\n", &red);
printf("Address held by pointer red %p\n", red);
printf("Value at address held by red %d\n", *red);

*alpha -= 1;
printf("\n*alpha -= 1\n");
printf("Address of pointer alpha %p\n", &alpha);
printf("Address held by pointer alpha %p\n", alpha);
printf("Value at address held by alpha %d\n", *alpha);
printf("\nNotice value at address held by alpha is one less\n");

alpha += 1;
printf("\nalpha += 1\n");
printf("Address of pointer alpha %p\n", &alpha);
printf("Address held by pointer alpha %p\n", alpha);
printf("Value at address held by alpha %d\n", *alpha);
printf("\nNotice alpha now points to address held by red\n");
}
</source>

=== Pointers to Structures===
Let's create a structure called vert and then create a pointer and
finally point to the structure.
<source lang="cpp">
MVert vert; /* creates structure variable "vert" */
MVert *vert_point; /* creates pointer to structure of type MVert */
vert_point = | /* assign address of variable vert to pointer */
</source>

=== Accessing Structure Data using Pointers===
We access the structure variables with the pointer using this syntax.
<source lang="cpp">
(*vert_point).mat_nr = 1; /* assigns 1 to mat_nr of structure */
printf("X co %f", (*vert_point).co[0]); /* print x coordinate */
</source>
We can simplify the readability of the code using a different syntax.
<source lang="cpp">
vert_point->mat_nr = 1; /* assigns 1 to mat_nr of structure */
printf("X co %f", vert_point->co[0]); /* print x coordinate */
</source>

=== Pointer to Structures Code Example===
In this example we access the structure variables with a pointer to the structure.
Compare this to the code in part 1.
<source lang="cpp">
/* Pointer to Structure Code Listing */

#include <stdio.h>

int main(void) {
/* declare structure */
typedef struct MVert {
float co[3]; /* array for vertex coordinates */
short no[3]; /* array for vertex normals */
char flag, mat_nr; /* variables for a flag and material index */
} MVert;

MVert vert; /* create variable of type MVert */
MVert *vert_point; /* create pointer to type MVert */
char key_press = '\0';

/* assign structure address to pointer */
vert_point = |

printf("\nWelcome to BabyBlender\n\n");
printf("To create a vertex press 'V'\n");
printf("Key: ");
scanf("%c", &key_press);
switch (key_press) {
case 'V':
case 'v':
/* assign values to the structure's array */
printf("Enter X coordinate: ");
scanf("%f", &(*vert_point).co[0]);
printf("Enter Y coordinate: ");
scanf("%f", &(*vert_point).co[1]);
printf("Enter Z coordinate: ");
scanf("%f", &(*vert_point).co[2]);

/* print the values from the structure's array */
printf("\nYour vertex is located at\n");
printf("X: %f\n", vert_point->co[0]);
printf("Y: %f\n", vert_point->co[1]);
printf("Z: %f\n", vert_point->co[2]);
break;
default: printf("That is not an option\n");
}
}
</source>

-- [[DeveloperWiki/DeveloperWikiStephenHughes|DeveloperWikiStephenHughes]] - 27 Apr 2005

[[Category:Script]]

← 古い版	2018年6月28日 (木) 17:51時点における版
(相違点なし)

Dev:Source/Data Structures/C Structures and Pointers - 版の履歴

Yamyam: 1版 をインポートしました

wiki>Adc: Minor code fixes.

Yamyam: 1版をインポートしました