指針魔術：結構與指針成員和更多

Question

我真的不知道如何給這個問題一個很好的標題 - 對不起。

就知道什麼是這一切的目標是：通過一個uint8_t變量的指針吧（），它不會將其設置爲1或0，我可以檢查它的裏面我的主要狀態。我確實需要zbar和（），這是一個線程，它的值實際上設置爲1或0

所以我有地方：

struct foo_t { 
    ... 
    uint8_t *state; 
}; 

，並在主我去：

int main(void) { 
    uint8_t state = 0; 
    bar(&state); 

    while(1) { 
      if(state) 
       //do something here 
    } 
} 

，在這裏我們有另一個源文件中的其他地方。

void bar(uint8_t *state) { 
    struct foo_t *foo; //using malloc here - don't worry 

    foo->state = state; 

    zbar(foo); 

}

void zbar(struct foo_t *arg) { 
    if(condition) 
     arg->state = 1; 
    else 
     arg->state = 0; 
} 

如何使這方面的工作？ o0 zBar實際上可以訪問arg結構，根本不是問題。

請不要擔心我爲什麼這麼奇怪，它的線程等

Answer 1

我假設你的意思是void bar(uint8_t* state)？

它不會做我認爲你的意圖。我再次假設您想要更改main中的state變量？如果是這樣嘗試

struct foo_t { 
    uint8_t* state; // changed this to a pointer type. 
} 

void bar(uint8_t* state) { 
    struct foo_t *foo = blah blah; 
    foo->state = state; 
    zbar(foo); 
} 

void zbar(foo_t* arg) { 
    if (condition) 
     *(arg->state) = 1; 
    else 
     *(arg->state) = 0; 
} 

我tihnk這是你想要做什麼

Answer 2

bar()需求中使用通過指針把它的參數。另外，如果你想檢查main的狀態，你將需要調用zBar

void bar(uint8_t* state) { 
    struct foo_t *foo; //using malloc here - don't worry 
    foo->state = *state; 
    zbar(foo); 
    *state = foo->state; 
} 

您正確稱其爲main（bar(&state);）

注意，以後的路所指向的改變bool它現在這個代碼，一旦調用zbar，state將永不再改變。如果你想有一個線程訪問（和修改）的狀態，你需要將地址存儲在struct foo：

struct foo 
{ 
    // ... 
    uint8_t* state; 
}; 

，並改變bar：

void bar(uint8_t* state) { 
    struct foo_t *foo; //using malloc here - don't worry 
    foo->state = state; // no dereferencing 
    // zbar(foo); // start the thread using zbar 
} 

void zbar(struct foo_t *arg) { 
    if(condition) 
    *(arg->state) = 1; 
    else 
    *(arg->state) = 0; 
} 

然後*(foo->state)任何變化也將改變state在main

Answer 3

不，這是行不通的。首先，它不會編譯 - foo_t的state成員被定義爲uint8_t，但您試圖在其中存儲uint8_t *。如果通過使bar說明類似於foo->state = *state來解決此問題，那麼它仍然不起作用，因爲雖然bar正在傳遞一個指向main的state變量的指針，但它所做的只是將其解除引用一次，並將結果置於結構。

你可以聲明foo_t有uint8_t *成員，從main通過&state爲bar，並存儲在foo_t。或者（如果您的代碼結構允許）忘記foo_t，並將指針從main指向state至bar至zbar。也就是說，其中的一個：

struct foo_t { ...; uint8_t * state; ... }; 
void bar(uint8_t * state) { struct foo_t * foo; ...; foo->state = state; zbar(foo); ... } 
void zbar(struct foo_t * arg) { ...; *(arg->state) = 1; ... } 

[編輯補充：在這種情況下，你還需要聲明state震盪main，以警告其他線程可能會修改其值爲編譯]

或

void bar(uint8_t * state) { ...; zbar(state); ... } 
void zbar(uint8_t * state) { ...; *state = 1; ... } 

另外一句話。 「它用在線程等內部」對於做一些奇怪或醜陋的事情並不是一個很好的理由。如果有一個具體的原因爲什麼你要用線程做的事情需要它，當然這是另一回事，當然你沒有義務在這裏捍衛你的設計決定 - 我只是要小心你反對看到「這裏是線程」作爲一般許可證做奇怪的事情。

Answer 4

我認爲你的意思是：

• 線程1個運行main和有一個局部變量uint8_t state
  • 它會檢查這個局部變量的值環路，期待它可以異步通過zbar
• 線程zbar
  • 時zbar改變的arg->state的價值，你想main看到線程的新值更新2個運行（除其他事項外）1

所以，首先，你需要確保arg->state和main S」本地state變量實際上是指內存中的相同位置。由於bar已經分配foo_t arg，它可能更容易作出這樣的共享副本：

int main(void) { 
    foo_t *arg = bar(); 

    while(1) { 
     if(arg->state) 
      ; //do something here 
    } 
} 

其次，你需要在該位置，以確保main實際上看到新的價值：爲INFACT說，有幾件事可能會阻止這一點。最明顯的是，沒有要求main到有史以來在第一次調用bar後重新加載state的值，因爲它看不到任何可能改變它的東西。

這東西本質上是不可移植的;告訴我們該平臺，我們將能夠提供更多信息。