The Big Programming Thread - Page 867

(*struct).field

or

struct->field

(**struct).field

or

(*struct)->field

or

??

how do I do it with just the arrows?

(*(struct)->field)->field

(*((struct)->field))->field

(struct->field).field

On April 02 2017 00:09 travis wrote:
Prillan, your last question. No it's just my lack of understanding.

Current C project I am having to do right now is most confusing one yet.

Boiled down it's essentially it's manipulating a structure that holds an array of linked lists of another structure. Which probably sounds easy to most of you but it is hell for me

edit, question:

accessing field of struct pointer, you can do

(*struct).field

or

struct->field

accessing field of struct double pointer

(**struct).field

or

(*struct)->field

or

??

how do I do it with just the arrows?

typedef struct clazz {
    type field;
} clazz_t;

int main() {
    clazz_t** var;

    // all at once, brackets are important
    (*var)->field;

    // equivalently
    (*(*var)).field;


     // conceptually it helps to use an intermediate variable, dereferencing the 'outer' pointer
    clazz_t* inter = *var;

    // you learned this as a short-hand
    inter->field;

    // equivalent to this
    (*inter).field;
}

(*(struct)->field)->field

(*((struct)->field))->field

(struct->field).field

bar** foo;

mytype myvar = (*foo)->myfield;
mytype myvar = (**foo).myfield;

*(double pointer + 1) = another pointer // set the value at double pointer[1] to another pointer

clazz_t** arr = ...;
clazz_t** iter = arr; // get a pointer to the first array element, iter variable to avoid modifying original
iter = iter + 1; // move the pointer to the second array element (next index in the array)

clazz_t* ele = *iter; // get the second element in the array
*ele = <new_value>; // change the value of the second array element

*iter = <new_element>; // change the second array element to another pointer (different than above)

void func(int** ptr) {
    *ptr = 4;
}

int main() {
    int* a = nullptr;
    func(&a);    
    // a is now 4
}

void func(int** ptr) {
    ptr = 4;
}

int main() {
    int* a = nullptr;
    func(&a);
    // a is still 0
}

On April 03 2017 00:54 Blisse wrote:

Show nested quote +

On April 02 2017 00:09 travis wrote:
Prillan, your last question. No it's just my lack of understanding.

Current C project I am having to do right now is most confusing one yet.

Boiled down it's essentially it's manipulating a structure that holds an array of linked lists of another structure. Which probably sounds easy to most of you but it is hell for me

edit, question:

accessing field of struct pointer, you can do

(*struct).field

or

struct->field

accessing field of struct double pointer

(**struct).field

or

(*struct)->field

or

??

how do I do it with just the arrows?

If you have

typedef struct clazz {
    type field;
} clazz_t;

int main() {
    clazz_t** var;

    // all at once, brackets are important
    (*var)->field;

    // equivalently
    (*(*var)).field;


     // conceptually it helps to use an intermediate variable, dereferencing the 'outer' pointer
    clazz_t* inter = *var;

    // you learned this as a short-hand
    inter->field;

    // equivalent to this
    (*inter).field;
}

#include <iostream>

using namespace std;

struct Y {
    int F;
};

struct X {
    Y* pY;
};

int main(int argc, char** argv) {
    Y y;
    y.F = 5;
    Y * pY = &y;
    X x;
    x.pY = pY;
    X * pX = &x;
    cout << (pX->pY)->F;
    return 0;
}

new = malloc(whatever)
//assign some stuff to new
curr->next = new;

new = malloc(whatever)
//assign stuff to new
new->next = curr;
curr = new;

void travis(int * a1)
{
  *a1 = 6;
  a1 = void;
}

int main()
{
  int *curr = 1;
  travis(curr);
}

[curr]
1

[curr] <---------- [a1]
1

[curr] <----------- [a1]
6

[curr]               [a1] -> void
6

[curr]
6

On April 03 2017 06:29 travis wrote:
I seriously need help
my brain is dying, you guys wouldn't believe how long I have been working on one function

...

I am actually going crazy.

void f(int a); // modifications to 'a' inside f do not affect the caller

void f(int* a) {
  int x = *a; //read to local var
  ... // do stuff - no pointers in here
  *a = x; // update caller
}

void f(struct S s) { ... }

void* dosomething() {
  blablabla
  foo: bla
  blablabla
}

void* dosomethingelse() {
  blabla
  if(condition) {
    goto foo;
  }
  blabla
}

loop1:
for(somestuff) {
  while(true) {
    break loop1;
  }
}