2. 程式人生 > >結構體中字串賦值

結構體中字串賦值

阿新 • • 發佈：2019-01-08 

#include <iostream> 
using namespace std; 

struct student 
{ 
  int num; 
  char name[10]; 
}; 

int main() 
{ 
  student st; 
  st.num = 10; 
  //st.name = "linjunjie"; //字串不能用=賦值
  strcpy(st.name, "linjunjie");
  return 0; 
}


結構體中string成員變數賦值

#include<string>
using namespace std;
struct temp
{
string s;
};
int main()
{
const string p="aaa";
temp *q;
q=(struct temp*)malloc(sizeof(struct temp));
q->s=p;
}


　　上述那種情況的賦值會導致程式中斷
　　需要用用new來分配記憶體，malloc不會呼叫結構函式
結構體內的string不定長，不能動態分配記憶體。

#include<string>
using namespace std;
struct temp
{
string s;
};
int main()
{
const string p="aaa";
temp *q;
//q=(struct temp*)malloc(sizeof(struct temp));
q = new temp;
q->s=p;

C++的結構體和類都有預設建構函式的，不寫都會自動實現一個。
　　malloc只是分配記憶體。


　　new除了分配記憶體還會呼叫建構函式的。

今天來討論一下C中的記憶體管理。

記得上週在飯桌上和同事討論C語言的崛起時，講到了記憶體管理方面
我說所有指標使用前都必須初始化，結構體中的成員指標也是一樣
有人反駁說，不是吧，以前做二叉樹演算法時，他的左右孩子指標使用時難道有初始化嗎
那時我不知怎麼的想不出理由，雖然我還是堅信要初始化的

過了幾天這位同事說他試了一下，結構體中的成員指標不經過初始化是可以用（左子樹和右子樹指標）
那時在忙著整理文件，沒在意
今天抽空調了一下，結論是，還是需要初始化的。
而且，不寫程式碼你是不知道原因的（也許是對著電腦久了IQ和記性嚴重下跌吧）
測試程式碼如下

 

C程式碼 複製程式碼
  1. #include 
  2. #include 
  3. #include 
  4. struct student{   
  5. char *name;   
  6. int score;   
  7. struct student* next;   
  8. }stu,*stu1;    
  9. int main(){    
  10.   stu.name = (char*)malloc(sizeof(char)); /*1.結構體成員指標需要初始化*/
  11.   strcpy(stu.name,"Jimy");   
  12.   stu.score = 99;   
  13.   stu1 = (struct student*)malloc(sizeof(struct student));/*2.結構體指標需要初始化*/
  14.   stu1->name = (char*)malloc(sizeof(char));/*3.結構體指標的成員指標同樣需要初始化*/
  15.   stu.next  = stu1;   
  16.   strcpy(stu1->name,"Lucy");   
  17.   stu1->score = 98;   
  18.   stu1->next = NULL;   
  19.   printf("name %s, score %d \n ",stu.name, stu.score);   
  20.   printf("name %s, score %d \n ",stu1->name, stu1->score);   
  21.   free(stu1);   
  22. return 0;   
  23. }  
#include 
#include 
#include 

struct student{
  char *name;
  int score;
  struct student* next;
}stu,*stu1; 

int main(){     
  stu.name = (char*)malloc(sizeof(char)); /*1.結構體成員指標需要初始化*/
  strcpy(stu.name,"Jimy");
  stu.score = 99;

  stu1 = (struct student*)malloc(sizeof(struct
student));/*2.結構體指標需要初始化*/
  stu1->name =
(char*)malloc(sizeof(char));/*3.結構體指標的成員指標同樣需要初始化*/
  stu.next  = stu1;
  strcpy(stu1->name,"Lucy");
  stu1->score = 98;
  stu1->next = NULL;
  printf("name %s, score %d \n ",stu.name, stu.score);
  printf("name %s, score %d \n ",stu1->name, stu1->score);
  free(stu1);
  return 0;
}



寫測試程式碼的過程中我明白了，同事所說的二叉樹遍歷演算法中所用的左子樹和右子樹指標不需要初始化，其實是這樣的，左子樹和右子樹指向的必須是二叉樹節點型別的結構體指標（你填一個長度相同的指標也可以），而該結構體指標是需要初始化的（見註釋2），也就是並沒有通過malloc來分配記憶體，而是將另一個指標的值賦給它

頓時覺得挺無語的，確實，看了很多大學裡的教材，對於二叉樹的遍歷等演算法定義的結構體無非是以下形式
 

C程式碼 複製程式碼
  1. struct node{   
  2. int data;   
  3. struct node* lchild, rchild;   
  4. };  
struct node{
  int data;
  struct node* lchild, rchild;
};


使用時都直接的
 

C程式碼 複製程式碼
  1. struct node* root;   
  2.  root = (struct node*)malloc(sizeof(struct node));   
  3.  root->data = 3;   
  4. struct node* nlchild;   
  5.  nlchild = (struct node*)malloc(sizeof(struct node));   
  6.  root->lchild = nlchild;   
  7.  nlchild->data = 2;    
  8. struct node* nrchild;   
  9.  nlrchild = (struct node*)malloc(sizeof(struct node));   
  10.  root->rchild = nrchild;   
  11.  nrchild->data = 4;   
 struct node* root;
  root = (struct node*)malloc(sizeof(struct node));
  root->data = 3;

  struct node* nlchild;
  nlchild = (struct node*)malloc(sizeof(struct node));
  root->lchild = nlchild;
  nlchild->data = 2; 

  struct node* nrchild;
  nlrchild = (struct node*)malloc(sizeof(struct node));
  root->rchild = nrchild;
  nrchild->data = 4;


這樣子給人造成一種錯覺好像結構體成員指標是不用初始化的。

可是，只要是指標，要使用它前就必須保證指標變數的值是一個有效的值；否則，它指向的記憶體一定是垃圾資料！
C語言的記憶體管理很重要，集魄力和麻煩於一身，看你自己的心態如何了。如果你積極的面對，你正在控制一切；如果你覺得煩躁，你正不得不控制一切。C仍舊是博大精深的語言，信C哥！

/*附加：仍舊是指標*/
 

C程式碼 複製程式碼
  1. stu1 = (struct student*)malloc(sizeof(struct student));/*2.結構體指標需要初始化*/
  stu1 = (struct student*)malloc(sizeof(struct
student));/*2.結構體指標需要初始化*/


這一句可能會有人把sizeof裡邊也填成struct student*
可以理解這樣的行為，因為stu本來就是struct student*，可是這樣子你就沒有為結構體分配足夠的記憶體，使用中會因為記憶體錯誤同樣報錯的。
當然，僅僅為結構體指標分配記憶體還不夠，結構體成員指標仍然需要分配記憶體，如下
 

C程式碼 複製程式碼
  1. stu1->name = (char*)malloc(sizeof(char));  

自己在用結構體指標的時候遇到的引用問題，網上找的一段文字覺得挺不錯的，可能對大家有幫助。

在使用結構體指標變數的時候，往往容易犯一個“低階”錯誤。即定義一個結構體指標變數後就直接對結構體指標變數所指向的結構體成員進行操作，從而產生一些莫名其妙的錯誤。我們必須要給結構體指標變數賦予一個有效的結構體變數地址，才能正常操作結構體指標變數。比如：

struct UART{

             int a;

             uchar b;

          }

main()

{

      struct UART  *p;

      p->a = 0xXXX;

      p->b = 0xXX;

     printf("%i,%c",p->b,p->a);

}

這個程式輸出的值將是不可預知的，因為“在程式中只是定義了一個結構體指標變數，並沒有給該結構體指標變數賦一個有效值，因此該結構體變數所指向的地址將不確定，從而不能得到預期結果”

應該改為：

struct UART{

             int a;

             uchar b;

       }

main()

{

      struct UART  *p;

     struct UART dd；

      p = &dd；               //這句一定要有，否則將出現不可預知的問題

      p->a = 0xXXX;

      p->b = 0xXX;

     printf("%i,%c",p->b,p->a);

}

C/C++中

結構體(struct)知識點強化 為了進一部的學習結構體這一重要的知識點，我們今天來學習一下連結串列結構。

　　結構體可以看做是一種自定義的資料型別，它還有一個很重要的特性，就是結構體可以相互巢狀使用，但也是有條件的，結構體可以包含結構體指標，但絕對不能在結構體中包含結構體變數。

　　 struct test
　　 {
　　 char name[10];
　　 float socre;
　　 test *next;
　　 };//這樣是正確的!
　　 struct test
　　 {
　　 char name[10];
　　 float socre;
　　 test next;
　　 };//這樣是錯誤的!

　　 利用結構體的這點特殊特性，我們就可以自己生成一個環環相套的一種射線結構，一個指向另一個。

　　連結串列的學習不像想象的那麼那麼容易，很多人學習到這裡的時候都會碰到困難，很多人也因此而放棄了學習，在這裡我說,一定不能放棄，對應它的學習我們要進行分解式學習，方法很重要，理解需要時間，不必要把自己逼迫的那麼緊，學習前你也得做一些最基本的準備工作，你必須具備對堆記憶體的基本知識的瞭解，還有就是對結構體的基本認識，有了這兩個重要的條件，再進行分解式學習就可以比較輕鬆的掌握這一節內容的難點。

　　下面我們給出一個完整的建立連結串列的程式，不管看的懂看不懂希望讀者先認真看一下，想一想，看不懂沒有關係，因為我下面會有分解式的教程，但之前的基本思考一定要做，要不即使我分解了你也是無從理解的。

　　 程式碼如下，我在重要部分做了註解：

　　 #include
　　 using namespace std;

　　 struct test
　　 {
　　 char name[10];
　　 float socre;
　　 test *next;
　　 };

　　 test *head;//建立一個全域性的引導進入連結串列的指標

　　 test *create()
　　 {
　　 test *ls;//節點指標
　　 test *le;//鏈尾指標
　　 ls = new test;//把ls指向動態開闢的堆記憶體地址
　　 cin>>ls->name>>ls->socre;
　　 head=NULL;//進入的時候先不設定head指標指向任何地址,因為不知道是否一上來就輸入null跳出程式
　　 le=ls;//把鏈尾指標設定成剛剛動態開闢的堆記憶體地址,用於等下設定le->next,也就是下一個節點的位置

　　 while(strcmp(ls->name,"null")!=0)//建立迴圈條件為ls->name的值不是null,用於迴圈新增節點
　　 {
　　 if(head==NULL)//判斷是否是第一次進入迴圈
　　 {
　　 head=ls;//如果是第一次進入迴圈,那麼把引導進入連結串列的指標指向第一次動態開闢的堆記憶體地址
　　 }
　　 else
　　 {
　　 le->next=ls;//如果不是第一次進入那麼就把上一次的鏈尾指標的le->next指向上一次迴圈結束前動態建立的堆記憶體地址
　　 }
　　 le=ls;//設定鏈尾指標為當前迴圈中的節點指標,用於下一次進入迴圈的時候把上一次的節點的next指向上一次迴圈結束前動態建立的堆記憶體地址
　　 ls=new test;//為下一個節點在堆記憶體中動態開闢空間
　　 cin>>ls->name>>ls->socre;
　　 }

　　 le->next=NULL;//把鏈尾指標的next設定為空,因為不管如何迴圈總是要結束的,設定為空才能夠在迴圈顯連結串列的時候不至於死迴圈
　　 delete ls;//當結束的時候最後一個動態開闢的記憶體是無效的,所以必須清除掉
　　 return head;//返回鏈首指標
　　 }

　　 void showl(test *head)
　　 {
　　 cout<<"鏈首指標:"< <
　　 while(head)//以記憶體指向為null為條件迴圈顯示先前輸入的內容
　　 {
　　 cout< name<<"|"< socre<
　　 head=head->next;
　　 }
　　 }

　　 void main()
　　 {
　　 showl(create());
　　 cin.get();
　　 cin.get();
　　 }
　　 上面的程式碼我們是要達到一個目的：就是要儲存你輸入的人名和他們的得分，並且以鏈狀結構把它們組合成一個鏈狀結構。

程式種有兩個組成部分
　　 test *create()
　　 和 void showl(test *head)
　　 這兩個函式，create是用來建立連結串列的 ，showl是用來顯示連結串列的。

　　 create函式的返回型別是一個結構體指標，在程式呼叫的時候我們用了showl(create());，而不用引用的目的原因是引導指標是一個全域性指標變數，我們不能在showl()內改變它，因為showl()函式內有一個移動操作head=head->next;，如果是引用的話我們就破壞了head指標的位置，以至於我們再也無法找會首地址的位置了。

　　 下面我們來分解整個程式，以一個初學者的思想來思考整個程式，由淺入深的逐步解釋。

　　首先，我們寫這個程式，要考慮到由於是一個連結串列結構，我們不可能知道它的大小到底是多大，這個問題我們可以用動態開闢堆記憶體來解決，因為堆記憶體在程式結束前始終是有效的，不受函式棧空間生命期的限制，但要注意的是我們必須有一個指標變數來儲存這一鏈狀結構的進入地址，而在函式內部來建立這一指標變數顯然是不合適的，因為函式一旦退出，這個指標變數也隨之失效，所以我們在程式的開始聲明瞭一個全域性指標變數。

　　 test *head;//建立一個全域性的引導進入連結串列的指標
　　 好解決了這兩個問題，我們接下去思考

　　有輸入就必然有輸出，由於輸出函式和輸入函式是相對獨立的，為了不斷測試程式的正確性好除錯我們先寫好輸出函式和main函式捏的呼叫，建立函式我們先約定好名為create。

　　 我們先寫出如下的程式碼：

　　 #include
　　 using namespace std;

　　 struct test
　　 {
　　 char name[10];
　　 float socre;
　　 test *next;
　　 };

　　 test *head;//建立一個全域性的引導進入連結串列的指標

　　 test *create()
　　 {

　　 return head;//返回鏈首指標
　　 }

　　 void showl(test *head)
　　 {
　　 cout<<"鏈首指標:"< <
　　 while(head)//以記憶體指向為null為條件迴圈顯示先前輸入的內容
　　 {
　　 cout< name<<"|"< socre<
　　 head=head->next;
　　 }
　　 }

　　 void main()
　　 {
　　 showl(create());
　　 cin.get();
　　 cin.get();
　　 }
　　 程式寫到這裡，基本形態已經出來，輸入和呼叫我們已經有了。

　　下面我們來解決輸入問題，連結串列的實現我們是通過迴圈輸入來實現的，既然是迴圈我們就一定得考慮終止迴圈的條件，避免死迴圈和無效迴圈的發生。

　　 在create()函式內部我們先寫成這樣：

　　 test *create()
　　 {
　　 test *ls;//節點指標
　　 test *le;//鏈尾指標
　　 ls = new test;//把ls指向動態開闢的堆記憶體地址
　　 cin>>ls->name>>ls->socre;
　　 head=NULL;//進入的時候先不設定head指標指向任何地址,因為不知道是否一上來就輸入null跳出程式
　　 le=ls;//把鏈尾指標設定成剛剛動態開闢的堆記憶體地址,用於等下設定le->next,也就是下一個節點的位置

　　 le->next=NULL;//把鏈尾指標的next設定為空,因為不管如何迴圈總是要結束的,設定為空才能夠在迴圈顯連結串列的時候不至於死迴圈
　　 delete ls;//當結束的時候最後一個動態開闢的記憶體是無效的,所以必須清除掉
　　 return head;//返回鏈首指標
　　 }
　　 在迴圈建立之前我們必須考慮一個都不輸入的情況。

　　程式一單進入create函式我們首先必然要建立一個節點，我們先建立一個節點指標，後把者個節點指標指向到動態開闢的test型別的動態記憶體地址位置上。

　　 test *ls;
　　 ls = new test;
　　 程式既然是迴圈輸入，而結構成員test *next又是用來儲存下一個接點的記憶體地址的，每次迴圈我們又要動態建立一個新的記憶體空間，所以我們必須要有一個指標來儲存上一次迴圈動態開闢的記憶體地址，於是就有了

　　 test *le;
　　 接下來在進入迴圈前我們要建立連結串列的第一個節點，第一個節點必然是在迴圈外建立，於是就有了

　　 cin>>ls->name>>ls->socre;
　　程式執行者的情況是位置的，所以我們必然要考慮，一上來就不想繼續執行程式的情況，所以我們一開始先把head引導指標設定為不指向任何地址也就是

　　 head=NULL;

　　為了符合le也就是鏈尾指標的設計思路，我們在迴圈前一定要儲存剛剛動態開闢的記憶體地址，好在下一次迴圈的時候設定上一個節點中的next成員指向，於是我們便有了：

　　 le=ls;
　　 為了實現迴圈輸入我們又了下面的程式碼：

相關推薦

結構體中字串賦值

#include <iostream> using namespace std; struct student { int num; char name[10]; }; int main() { student st;

結構體中指標賦值問題的分析及C程式碼示例

問題描述 某結構體的定義如下： typedef struct { int iAge; // 年齡 char szAddr1[100]; // 地址1 char *psz

C語言中結構體的直接賦值

這篇文章當時寫的比較隨意，考慮到看到這篇文章的人比較多，我重新寫了一篇比較完整的釋出在我的新部落格中，大家可以參考： 一直記得C語言中，結構體是不可以直接賦值的。我問了三個同學，都說在C++中可以，在C語言中不可以，需要逐一成員賦值或者用memcpy函式

C語言中結構體變數之間賦值

/********************************************************************** * 版權所有 (C)2015, Zhou Zhaoxiong。 * * 檔名稱：Struct2Struct.c * 檔案標識：無 * 內容摘要：結構體變數之間的賦值

函數外面對單個結構體成員進行賦值出錯

類型 自動 構造 不能 結構體成員 bsp 入口 出錯 進入 關於“為什麽整型的就可以，結構體類型的就不能這麽賦值呢？”——整形等常規數據類型由編譯器自動識別，而自定義的數據類型（樓主自定義的結構體類型），編譯器在編譯階段無法識別，故出錯。 關於“在函數外單個初始化”——在

【將檔案中字串賦值到 ArrayList 中】

package com.companyname.common.test; import java.io.BufferedReader; import java.io.FileReader; import java.io.IOException; import java.util.ArrayList;

c語言結構體可以直接賦值

結構體直接賦值的實現 下面是一個例項： #include <stdio.h> struct Foo { char a; int b; double c; }foo1, foo2; //define two str

C語言中字串賦值處理方式

C語言中，字串可以賦值給字元指標變數，或者將字串用字元陣列儲存。因為c語言沒有直接對字串提供語法糖方面的支援。而且C標準庫很多方法處理字串是以空字元結尾為前提的，這個必須要記住。 char *p,a='5'; p=&a;

結構體可直接賦值

#include "iostream" #include "vector" #include "algorithm" using namespace std; struct C { int

C語言，結構體中字串的宣告（採用字元指標還是字元陣列）

      結構體中，字串選項是用字元陣列表示好，還是用字元指標表示好？ typedef struct person{ char *name; int age; char sex[6]; }       該結構體中name用的是指標而不是陣列，所以需要給字串在堆上申

c結構體陣列的賦值語法細節

1. 上述程式最後輸出結構體陣列中字串的第一個字元。輸出 h 。 2 此段程式碼執行結果與上段相同,唯一區別就是陣列元素賦值時加了大括號, 第一段程式碼,雖然沒加大括號,但通過換行區別陣列元素.總之兩種寫法都正確. 這裡記錄一下,也避免自己以後大驚小怪,算是學習過程中的

Opencv中Mat結構體中元素的獲取與賦值

【OpenCV3影象處理】Mat中元素的獲取與賦值 （ 對比.at<>()函式 和 .ptr<>()函式） 2017年04月12日 10:08:55 閱讀數：7542 標籤： opencvopencv3 更多 個人分類：&nbs

C++：對結構體中字元陣列賦值時，出現表示式必須是可修改的左值的問題

問題描述：         在C++中為結構體中的字元陣列賦值時，出現”表示式必須是可修改的左值“的錯誤提醒，編譯報錯“不可指定資料型別”。           &n

如何給結構體中的字元陣列賦值。

舉例如下： char a[10]; 1、定義的時候直接用字串賦值 char a[10]="hello"; 注意：不能先定義再給它賦值，如 char a[10]; a[10]="hello"; 這樣是錯誤的！ 2、對陣列中字元逐個賦值 char a[10]={'h','e',

為結構體中函式指標賦值的兩種方法

/** 02. * 為結構體中的指標陣列賦值 03. */ 04. 05.#include <stdio.h> 06. 07.typedef struct test 08.{ 09. void (*p)(void); 10.

c 結構體中存在指標,指標的不同賦值方法

#include<stdio.h>#include<stdlib.h>#include<string.h>struct parameter{ char *fd; int hit;};int main() { struct parameter

C語言中，通過指標給結構體中的變數賦值

typedef struct Mech_Para// { int32_tP001_TipBoxX; int32_tP002_TipBoxY; int32_tP003_TipBoxZ; int32_tP004_IntervalX; int32_tP005_IntervalY;

C結構體中賦值使用的冒號和點號

根據論壇中，別人的回答，總結試驗的成果 1、其中位域列表的形式為： 型別說明符 位域名：位域長度 struct bs { 　int a:8; 　int b:2; 　int c:6; }data; 說明data為bs變數，共佔兩個位元組。其中位域a佔8位，位域b佔2位，位域c

結構體中的陣列成員的賦值問題

#include <iostream> using namespace std; struct student {   char name[20];   int age; }; int main( ) {  student s;  s.name="gyy";

使用tolua++匯出C++物件中的字串賦值問題

   tolua++能夠將c++中的物件匯出到lua中，並在lua中賦值，但對於字串，卻存在支援上的問題，如： // tolua_begin  #define MAX_LEN 10 struct SExample {     int     Num;      ch