结构体指针初始化,怎样初始化一个结构体中指向另一个结构体的结构体指针变量

结构体指针初始化,怎样初始化一个结构体中指向另一个结构体的结构体指针变量详细介绍

本文目录一览： 结构体指针如何初始化

比如：
结构体如下：
typedef struct
{
void* Input;
void* Output;
volatile void* DmaBaseAddr;
volatile unsigned int* ITU656Reg;
volatile unsigned int* ITUResetReg;
}ITUManager;
代码如下：
struct ITUManager
{
void* Input;
void* Output;
volatile void* DmaBaseAddr;
volatile unsigned int* ITU656Reg;
volatile unsigned int* ITUResetReg;
} *Itu = NULL;
直接abc *p = NULL;就可以避免警告。不过你使用p存值或取值前一定要先分配内存
memset(p,0,sizeof(abc));把从p地址开始sizeof(abc)大小的空间置0；
开头要加上#include

或者直接写abc *p=NULL;

C语言结构体指针的初始化应该怎样理解？

1、structs{charc;inti;};struct*p1;/*p1是指向s结构体的指针*/2、typedefstruct{charc;inti;}s,*ps;s*p2;/*p2是指向结构体的指针*/psp3;/*p3是指向s结构体的指针*/

结构体指针数组怎么初始化？

#include

using namespace std;

#define MAX 27

typedef struct

{

char x;

int y;

}Quan,*QQuan;

void main()

{

QQuan a[MAX];

for(int i=0;i
<max;i++)
{

a[i]=new Quan;

a[i]->x='0';

a[i]->y=0;

}

for(i=0;i
<max;i++)
{

cout<

x<<"\t"<

y<
<endl;
}

}

自己看吧，相信你会看懂的，关键的一点就是new分配指针空间。

for(i=0;i
<max;i++)
{

a[i]=(QQuan)malloc(sizeof(Quan));

memset(a[i],0,sizeof(Quan));

}

需要引用

</max;i++)
</endl;


</max;i++)
</max;i++)

C语言结构体指针变量初始化

void
RegList(LB
*L)
//初始化线性表(建立头结点,指针域置为空)
{
L=(LB
*)malloc(sizeof(LB));
L->next=NULL;
}
改成指针的指针
调用的时候RegList(&k);就行了。
void
RegList(LB
**L)
{
*L
=
(LB*)malloc(sizeof(LB));
(*L)->next
=
NULL;
}

c语言结构体指针初始化，急

STUDENT
*p;
做到这一步的时候系统就开了一个STUDENT空间，长度就是STUDENT的长度。
如果你想让p的值为NULL的话你可以直接给p赋值NULL就可以了
比如
p=NULL;
或者return
NULL;
我一直不理解
for(i=0;i<=50;i++)
p->chEmail[i]=NULL;
是在干啥，
ZeroMemory(p,sizeof(p));这句应该就是把p指向的地址STUDENT长度的字节全赋0了
我一般喜欢用memset(p,0,sizeof(p));头文件是

p->chEmail[i]=NULL;

NULL是空指针，但是这么运算的时候会变成0。

最好对char类型赋空值的时候使用'\0'

C语言结构体指针中的const成员怎么初始化

楼主这种想法是错误的，是对概念的误解。根本不能这么写。
语法：禁写指针
声明语句格式为： 数据类型 * const 指针变量名
你看上面const后面要求的是指针变量名，它是一个变量。
而在结构体的定义中定义的只是数据的类型和名称，花括号{}中没有变量，变量在最后的花括号'}'后面分号';'前面。
struct s{//这时，未定义结构体变量，只是已将静态成员的空间大小安排好。
int id;//这里的id,eng根本不是一个变量，只是一个名称符号
int eng;//
};//变量在这里分号前面定义
所以下面的写法根本不合语法。
typedef struct {
int* const p; //p根本就不是变量嘛，怎么能放在禁写指针语法中
} C;
想不出来正常的方法...
不过你可以*(int **)&c->p = &i...
--
真热闹|||
“常量指针必须在定义时初始化。”C语言里不能在定义结构体的时候对成员初始化。
“楼主这种想法是错误的，是对概念的误解。根本不能这么写。 ”咱这些挂牌的说话负点责任好不好b...
“(int*)(c->p) = &i; // 最关键的一步。”gcc里允不允许这样我还真不知道... 但是左值不能直接类型转换的吧
我觉得你的大写的那个C，没有定义类型啊！~(int C*)malloc(sizeof(C)); 用const那你就得看看我的学习笔记
int x = 10;
int* p = &x;
*p = 20; //修改指针指向的内容
int y = 30;
p = &y; //修改指针保存的地址
const int *pp = &x; //不能通过*pp修改pp指向的内容，也就是定义pp为常量指针。也可以写成 int const *pp
//*pp = 50; 错的
pp = &y;
int* const qq = &x; //不能修改qq，也就是定义qq为指针常量
*qq = 50;
//qq = &y; 错的
const int* const ww = &x; //既不能修改ww指向的内容，也不能修改ww本身。也就是定义ww为指向常量的指针常量。
//*ww = 50; 错
//ww = &y;错
1、方法是有的，不过并不太赞成这种做法，不过如果仅仅是作为初始化使用的话，可以先定义一个初始化的函数，并保证在别的地方不再调用这个函数，倒也可以行。
2、代码如下：
#include

#include

typedef struct{

int* const p;} C;int main(){int i = 0;

C* c = (C*)malloc(sizeof(C));

printf("Old: 0x%08X\n", c-p);

p为常指针，指针所指向的地址是不能改变的，但指向的内容可以改变

把c->p = &i, 改为*C->p = i 但c->p又是指向空，不能够存储内容

所以要(int *)c->p = &i;

方法是有的，不过并不太赞成这种做法，不过如果仅仅是作为初始化使用的话，可以先定义一个初始化的函数，并保证在别的地方不再调用这个函数，倒也可以行，代码如下：

#include

#include

typedef struct

{

int* const p;

} C;

int main()

{

int i = 0;

C* c = (C*)malloc(sizeof(C));

printf("Old: 0x%08X\n", c->p);

(int*)(c->p) = &i; // 最关键的一步。

printf("new: 0x%08X\n", c->p);

free(c);

return 0;

}

----------------------------------- 补充1

C中是没有构造函数的概念的，所以妄图想C++那样在对象构造的同时对对象进行初始化是误解的，唯一的方法就是写一个特殊的函数，用这个函数来初始化一个结构体的内存，甚至可以用memset()函数都可以，所以你的要求已经退化成如何对结构体进行初始化了，这是很多C++程序员回头写C程序的时候，都会反复思考的问题。

定义了一个结构体，结构体有个成员变量是指针类型，而这个变量有是结构体，请问怎么对这个指针初始化？

struct A
{
int a;
struct B *b;
}
sturct B
{
int x;
}
struct A *sta = NULL;
sta = (struct A *)malloc(sizeof(struct A));
memset(sta, 0, sizeof(struct A));
sta->b = (struct B*)malloc(sizeof(struct B));
memset(sta->b, 0, sizeof(struct B));
sta初始化完成
例如有a,b两个结构体,a中有b
在main中需要先初始化个b,完成b之后，然后调用a.**=b，这样就可以完成了！ 如果直接调用a的话，有可能溢出……！
没赋具体值时都给NULL就好
struct A *a = (struct A *)malloc(sizeof(struct A ));
memset(a,0,sizeof(struct A ));
struct A{
int x;
}
struct B{
int y
A *z;
}b={2,NULL};

怎样初始化一个结构体中指向另一个结构体的结构体指针变量

typestruct
Stu
{
int
stu
}
stu;
typedef
struct
MyStu
{
stu
*t;
int
mystu;
}mystustudent;
int
main()
{
mystudent
*
p
=
malloc
(sizeof(struct
Mystu));
//这里面你只是为mystudent这个结构体开辟了一个空间，由p来指向这个空间，但是我们要确定一点，就是这个空间里面存放了一个指针（它仅仅开辟了一个指针的空间和一个int
大小的空间），至于这个指针指向的地址呢？？？？？你还没有分配呢！！，下面必须要进行分配了
stu
*t
=
malooc(sizeof(struct
Stu));其实这是很没必要的！因为我们完全可以用普通类型来实现
typedef
Mystu
{
stu
t;
int
mystu;
}
这样的话
p
指针开放的空间就是由stul类型的t
结构体空间和一个int类型的空间组成，何必再去动态开配一个空间呢！
}

C语言结构体成员指针初始化问题

一中只是将name指向“jim”所在的空间，”jim“已经存在了，直接将指针指向他即可，而二中是复制一个”jim“到name所指向的空间，没有初始化当然不行
第一个"jim"返回的是一个地址，是正确的。第二个内存分配小了。
问题：（一）中的student.name并未初始化，为什么能赋值成功？
stu.name = "jim"; "jim"; 是字符串常量，系统自动为他分配了内存并保存这些字符，执行赋值操作是，将这个字符串的首地址复制给 stu.name。
（二）偶用strcpy_s函数时有疑问，strcpty（str1,int,str2）中 sizeof（str1）>int&&int>sizeof(str2)
strcpy_s和strcpy()函数的功能几乎是一样的。strcpy函数，就象gets函数一样，它没有方法来保证有效的缓冲区尺寸，所以它只能假定缓冲足够大来容纳要拷贝的字符串。在程序运行时，这将导致不可预料的行为。用strcpy_s就可以避免这些不可预料的行为。
这个函数用两个参数、三个参数都可以，只要可以保证缓冲区大小。
三个参数时：
errno_t strcpy_s(
char *strDestination,
size_t numberOfElements,
const char *strSource
);
两个参数时：
errno_t strcpy_s(
char (&strDestination)[size],
const char *strSource)
例如：
char *str1=NULL;
str1=new char[20];
char str[7];
strcpy_s(str1,20,"hello world");//三个参数
strcpy_s(str,"hello");//两个参数但如果：char *str=new char[7];会出错：提示不支持两个参数