精华内容
下载资源
问答
  • 这是C++中的一个虚方法 TapAPITradeLoginAuth 是个结构体 ...下面请各路大神讲解一下调用的方法 我知道用【DllInport】 来引用dll 但是C++这个方法后买年是个结构体指针小弟就搞不明白在C#中要怎么转换
  • const修饰结构体指针

    2021-02-08 17:13:43
    const修饰结构体指针 #include<iostream> using namespace std; #include<string> //定义一个结构体 struct student { string name; int age; int score; }; void printfStudent( const struct ...

    const修饰结构体指针

    #include<iostream>
    using namespace std;
    #include<string>
    //定义一个结构体
    struct student
    {
    	string name;
    	int age;
    	int score;
    };
    
    void printfStudent( const struct student* q1)
    //在函数中将形参改为指针,这样可以减少内存,不会复制多的副本
    //const 结构体指针可以避免误修改主函数实参
    {
    	
    	cout << "子函数中 姓名  " << q1->name << "  年龄  " << q1->age << "  分数  " << q1->score << endl;
    
    };
    int main()
    {
    	//定义一个结构体变量
    	student q1;
    	q1.name = "WUNGF";
    	q1.age = 21;
    	q1.score = 90;
    	printfStudent(&q1);
    	cout << "主函数 姓名  " << q1.name << "  年龄  " << q1.age << "  分数  " << q1.score << endl;
    	system("pause");
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • C学习:const修饰、结构体指针及位域使用 const的临近修饰用法 const在前面 const int nValue; // nValue是const const char *pContent; // *pContent是const, pContent可变 const char* const pContent; //...

    C学习:const修饰、结构体指针及位域使用


    const的临近修饰用法

    • const在前面
    const int nValue; // nValue是const
    const char *pContent; // *pContent是const, pContent可变
    const char* const pContent; // pContent 和 *pContent都是const
    • const在后面,与上面的声明对等
    int const nValue; // nValue是const
    char const * pContent; // *pContent是const, pContent可变
    char* const pContent; // pContent是const, *pContent可变
    char const* const pContent; // pContent 和 *pContent都是const

    根据上面的例子和注释简单总结为:const跳过其后的数据类型修饰其后的变量(括号可以限定修饰范围)

    如上面的const char *pContent; 语句,const修饰后面的“*pContent”,故而*pContent是const的;
    又如语句“char* const pContent; ”,const修饰其后的“pContent”,故而pContent是const的。


    结构体指针

    结构体指针的用法

    通过结构体指针变量获得其结构体变量的成员变量有两种方式:

    • (*结构体指针变量). 成员变量
    • 结构体指针变量->成员变量

    其中,“.”为取结构体成员变量的运算符。
    另外C语言中引入了新的运算符“->”用于结构体指针变量直接获得结构体变量的成员变量

    typedef struct BirthDay   
    {
        int year;
        int month;
        int day; 
    } BirthDay_T;
    
    typedef struct Stu
    {
        char name[20];  
        long num;  
        BirthDay_T birthday;
    } Stu_T;  
    
    int main()
    {
        ...
        Stu_T student = {0};
        Stu_T *pStu; /*定义结构体类型指针*/
    
        //pStu = malloc(sizeof(Stu_T)); /*为指针变量分配安全的地址*/  
        printf("Input name, number, year, month, day:\n");  
        scanf("%s", student.name); 
        scanf("%ld", student.num); 
        ...
    
        pStu = &student;
    
        student.name = "wangerqiang" /* error */
    
        ...
    }

    pStu = &student是将student的地址存储在结构体指针变量pStu中,*pStu代表指针变量student中的内容,因此*pStu 和student等价,所以:

    (*pStu).num = student.num;
    (*pStu).birthday.year = student.birthday.year;
    等价于
    pStu->num = student.num;
    pStu->birthday.year = student.birthday.year;

    另外语句student.name = “wangerqiang”编译报错,需要注意的是student.name是数组名,代表数组的首地址(地址常量),给常量赋值是非法的。

    指向结构体数组的指针的使用

    int main()
    {
        ...
        Stu_T student[100] = {0};
        Stu_T *pStu; /*定义结构体类型指针*/
        ...
    
        pStu = &student;
        ...
    
        pStu++;
        ...
    }

    以上程序对结构体数组student元素的引用可采用三种方法:

    • 地址法
    student+i和pStu+i均表示数组第i个元素的地址,数组元素成员的引用形式为:
    (student+i)->name, (student+i)->num 和 (pStu+i)->name, (pStu+i)->num等.
    student+i 和 pStu+i 及 &student[i]意义相同。
    • 指针法
    若pStu指向数组的某一个元素,则pStu++就指向其后续元素。
    • 指针的数组表示法
    pStu = &student,pStu指向数组student,pStu[i]表示数组的第i个元素,其效果与student[i]等同。
    对数组成员的引用描述为:pStu[i].name, pStu[i].num

    位域的使用

    typedef struct
    {
        unsigned short u16_1 : 12;
        unsigned short u16_2 : 4;
    } U16BitField_Type;
    
    typedef struct
    {
        unsigned char u8_1 : 6;
        unsigned char u8_2 : 2;
    } U8BitField_Type;
    
    int main()
    {
        U16BitField_Type struc16 = {0};
        U8BitField_Type struc8 = {0};
        unsigned short *pU16 = NULL;
        unsigned char *pU8 = NULL;
    
        struc16.u16_1 = 0x0A98;
        struc16.u16_2 = 0x000F;
        pU16 = &struc16;
    
        struc8.u8_1 = 0x3A;
        struc8.u8_2 = 0x03;
        pU8 = &struc8;
    
        printf("struc16.u16_1:0x%X struc16.u16_2:0x%X *pU16:0x%X \n", struc16.u16_1, struc16.u16_2, *pU16);
        printf("struc8.u8_1:0x%X struc8.u8_2:0x%X *pU8:0x%X \n", struc8.u8_1, struc8.u8_1, *pU8);
    
       return 0;
    }

    结果是*pU16 = 0xFA98; *pU8 = 0xFA;
    注:测试处理器环境为小端

    展开全文
  • C语言 C++两个版本 txt 文件读取结构体信息,写入结构体指针中,并以结构体指针形式返回 附加功能:采用 直接插入排序 方法 按总成绩进行了降序排序 1、结构体信息如下: #define size 9 struct student//学生...

    C语言 C++两个版本 txt 文件读取结构体信息,写入结构体指针中,并以结构体指针形式返回
    txt文件行数未知
    附加功能:采用 直接插入排序 方法 按总成绩进行了降序排序
    1、结构体信息如下:

    #define size 9
    struct student//学生信息
    {
        long int number;
        char name[size];
        int Chinese;
        int math;
        int English;
        int totalScore;
    };

    2、txt文件(student_info.txt)中存储信息如下:

    179328  何芳芳 89  100 98
    179325  陈红  86  100 88
    179326  陆华  75  80  90
    179324  张小仪 85  57  94
    179327  张平  80  98  78
    179320  木子  100 96  89
    179329  海子  93  95  88

    3、子函数代码
    获取txt文件行数:

        char *fname="student_info.txt";
        ifstream in(fname);
        if (!in){ cout << "No such a file" << endl; return NULL; }
        //获取文件的行数--------------------------begin
        in.seekg(0, 2);//定位文件指针到文件末尾
        student s;
        len = in.tellg() / sizeof(s);//获得文件行数
        len += 2;//自己动手加上2行,目前不知道为什么,得到的行数总是比实际行数少两行??
        //获取文件的行数--------------------------end

    3.1、C++版本代码如下:
    思路:参考C++ txt 文件读取,并写入结构体中

    //利用 C++,将文件中的student类型的数据结构信息 取出来,放在一个student类型的结构指针中,并将student* 返回
    int len;//文件行数 全局变量
    student* CreateStudentFromFile(char *fname)
    {
        ifstream in(fname);
        if (!in){ cout << "No such a file" << endl; return NULL; }
    
        //获取文件的行数--------------------------begin
        in.seekg(0, 2);//定位文件指针到文件末尾
        student s;
        len = in.tellg() / sizeof(s);//获得文件行数
        len += 2;//自己动手加上2行,目前不知道为什么,得到的行数总是比实际行数少两行??
        //获取文件的行数--------------------------end
        in.seekg(0, 0);//再重新定位文件指针到文件头
    
        //---------将文件中的结构体写入到 结构体指针中----
        student *stu = new student[len];
        int i = 0;
        while (in >> s.number >> s.name >> s.Chinese >> s.math >> s.English)//之前一直错误的原因是写成了cin>>就是从键盘输入了!!
        {
            s.totalScore = s.Chinese + s.math + s.English;
            stu[i] = s;
            ++i;
        //  *stu++ = s;//错误,这样代替前两行 一定错误!! 暂时还不知道为什么??
        }
        in.close();
        //-----------------------------------------------
        return stu;
    }

    3.1、C语言版本代码如下:

    //将*.txt文件中的学生信息 存放到 学生结构体指针中,并返回该结构体指针
    student* CreateStudentFromFile2(char *fname)//C语言的文件就可以 Okay!!
    {
        FILE *f;
        f = fopen(fname, "r");
        if (!f){ cout << "No such a file" << endl; return NULL; }
    
        student s;
        fseek(f, 0, 2);//定位文件指针到文件末尾
        len = ftell(f) / sizeof(s);//获得文件行数//不知道为什么,这样得到的文件行数总是少两行??
        rewind(f);// 指针重新回到文件开始
        len += 2;
    
        student *stu = (student *)malloc(len*sizeof(student));
        int i = 0;
        for (int i = 0; i < len; ++i)
        {
            fscanf(f, "%ld%s%d%d%d", &s.number, &s.name, &s.Chinese, &s.math, &s.English);
            s.totalScore = s.Chinese + s.math + s.English;
        //  *stu++ = s;//错误
            stu[i] = s;
        }
    
        fclose(f);
        return stu;
    }

    4、测试代码

    #include<iostream>
    #include<fstream>
    
    #include<sstream>
    #include<string>
    
    using namespace std;
    
    #define size 9
    struct student
    {
        long int number;
        char name[size];
        int Chinese;
        int math;
        int English;
        int totalScore;
    };
    
    //利用 C++,将文件中的student类型的数据结构信息 取出来,放在一个student类型的结构指针中,并将student* 返回
    int len;//文件行数 全局变量
    student* CreateStudentFromFile(char *fname)
    {
        ifstream in(fname);
        if (!in){ cout << "No such a file" << endl; return NULL; }
    
        //获取文件的行数--------------------------begin
        in.seekg(0, 2);//定位文件指针到文件末尾
        student s;
        len = in.tellg() / sizeof(s);//获得文件行数
        in.seekg(0, 0);//再重新定位文件指针到文件头
        len += 2;
        //获取文件的行数--------------------------end
    
        //C++ txt 文件读取,并写入结构体中 https://blog.csdn.net/yuyefuxiao521/article/details/77183345
        //---------将文件中的结构体写入到 结构体指针中----
        student *stu = new student[len];
        int i = 0;
        while (in >> s.number >> s.name >> s.Chinese >> s.math >> s.English)//之前一直错误的原因是写成了cin>>就是从键盘输入了!!
        {
            s.totalScore = s.Chinese + s.math + s.English;
            stu[i] = s;
            ++i;
        //  *stu++ = s;//错误,这样代替前两行 一定错误!! 暂时还不知道为什么??
        }
        in.close();
        //-----------------------------------------------
    
        return stu;
    }
    
    //将*.txt文件中的学生信息 存放到 学生结构体指针中,并返回该结构体指针
    student* CreateStudentFromFile2(char *fname)//C语言的文件就可以 Okay!!
    {
        FILE *f;
        f = fopen(fname, "r");
        if (!f){ cout << "No such a file" << endl; return NULL; }
    
        student s;
        fseek(f, 0, 2);//定位文件指针到文件末尾
        len = ftell(f) / sizeof(s);//获得文件行数//不知道为什么,这样得到的文件行数总是少两行??
        rewind(f);// 指针重新回到文件开始
        len += 2;//自己动手加上2行
    
        student *stu = (student *)malloc(len*sizeof(student));
        int i = 0;
        for (int i = 0; i < len; ++i)
        {
            fscanf(f, "%ld%s%d%d%d", &s.number, &s.name, &s.Chinese, &s.math, &s.English);
            s.totalScore = s.Chinese + s.math + s.English;
        //  *stu++ = s;//错误
            stu[i] = s;
        }
    
        fclose(f);
        return stu;
    }
    
    void DestroyStudentStruct(student *&s)
    {
        if (s==NULL){ cout << "无信息" << endl; return; }
        delete[] s;
        s = NULL;
    }
    
    void disp(const student* s, int len)
    {
        if (s == NULL){ cout << "该学生尚未登记,暂无信息。" << endl; return; }
        for (int i = 0; i < len; ++i)
            printf_s("%ld\t%s\t%3d\t%3d\t%3d\t%3d\n", s[i].number, s[i].name, s[i].Chinese, s[i].math, s[i].English, s[i].totalScore);//%3d:保证三位数右对齐
    }
    
    //直接插入排序 按总成绩降序排列
    void InsertionSort(student* s, int len)
    {
        for (int i = 1; i < len; ++i)
        {
            for (int j = 0; j < i; ++j)
            {
                if (s[j].totalScore < s[i].totalScore)
                {
                    student temp = s[i];//这样的话,根据学号,调整学号所在对象的位置,整个Student对象 都会随着学号的升序而跟着改变
                    for (int k = i; k>j; --k)
                        s[k] = s[k - 1];
                    s[j] = temp;
                }
            }
        }
    }
    
    void test0()
    {
        cout << "------C++版本---test0()---将txt中的结构体信息写入到 结构体指针中--------" << endl;
        student *s = CreateStudentFromFile("student_info.txt");
    
        cout << "学号\t姓名\t语文\t数学\t外语\t总成绩" << endl;
        cout << "before insertion sort: " << endl;
        disp(s, len);
    
        InsertionSort(s, len);//插入法排序成功 //根据成绩排序
        cout << "after insertion sort: " << endl;
        disp(s, len);
        DestroyStudentStruct(s);
        cout << s << endl;
        disp(s, len);
    }
    void test()
    {
        cout << "------C语言版本---test()---将txt中的结构体信息写入到 结构体指针中--------" << endl;
        student *s = CreateStudentFromFile2("student_info.txt");
    
        cout << "学号\t姓名\t语文\t数学\t外语\t总成绩" << endl;
        cout << "before insertion sort: " << endl;
        disp(s, len);
    
        InsertionSort(s, len);//插入法排序成功 //根据成绩排序
        cout << "after insertion sort: " << endl;
        disp(s, len);
        DestroyStudentStruct(s);
        cout << s << endl;
        disp(s, len);
    }
    
    int main()
    {
        test0();
        test();
    
        return 0;
    }
    展开全文
  • 指针数组 指针数组是一个数组,数组的元素保存的是指针; 定义: int *p[size] //表示数组存的是指针,有size个指针数据 数组指针 数组指针是一个指针,该指针指向的是一个数组; 定义: int (*p)[size] //数组指针...

    指针数组

    指针数组是一个数组,数组的元素保存的是指针;
    定义:
    int *p[size] //表示数组存的是指针,有size个指针数据

    数组指针

    数组指针是一个指针,该指针指向的是一个数组;
    定义:

    int (*p)[size] //数组指针,存储size个int类型的数据

    指针函数与函数指针

    指针函数

    指针函数是一个函数,该函数返回的是一个指针;

    函数指针

    函数指针是一个指针,该指针指向一个函数;

    #include <stdio.h>
     
    int* getIntPoint(const int a) //指针函数,是一个函数 返回一个指针;
    {
    	int *p = nullptr ;
    	p = new int ;
    	*p = a; 
     	return p ;
    }
     
     
    int main(int argc, char const *argv[])
    {
    	int *(*p)(int)  = getIntPoint ; //函数指针,该指针指向一个函数;
    	int* pInt = p(5); //使用函数指针;
    	printf("%d\n",*pInt);
    	delete pInt ;
    	return 0;
    }
    
    #include <stdio.h>
    void print();
    int main(void)
    {
    	void (*fuc)(); 
    	fuc = print ; 
    	fuc(); 	
    } 
    void print()
    {
    	printf("hello world!\n");
    }
    

    回调函数

    函数指针变量可以作为某个函数的参数来使用的,回调函数就是一个通过函数指针调用的函数。

    #include <stdlib.h>  
    #include <stdio.h>
     
    // 回调函数
    void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
    {
        for (size_t i=0; i<arraySize; i++)
            array[i] = getNextValue();
    }
     
    // 获取随机值
    int getNextRandomValue(void)
    {
        return rand();
    }
     
    int main(void)
    {
        int myarray[10];
        populate_array(myarray, 10, getNextRandomValue);
        for(int i = 0; i < 10; i++) {
            printf("%d ", myarray[i]);
        }
        printf("\n");
        return 0;
    }
    

    结构体数组

    数组中存储的元素都是一个结构体,类似整型数组中存储的是int型。
    申明结构体数组:
    结构体名 数组名【size】

    结构体指针

    指向结构体的指针。
    结构指针变量说明的一般形式为:

    struct 结构体名 *结构体指针变量名
    struct student *p = &Boy; //假设事先定义了 struct student Boy;

    #include<stdio.h>
    #include<string.h>
    #include<malloc.h>
    
    typedef struct Errlog
    {
    	char str_file[1000];
    	int num;
    	int err;
    }errlog;
    
    int main(void)
    {
    	errlog err1[3];//结构体数组
    	errlog *err2;//结构体指针
    	errlog *err3[3];//结构体指针数组,表示数组存的是指针,有3个指针数据
    	errlog (*err4)[3];//结构体数组指针,是一个指针,该指针指向的是一个数组,该数组存储3个errlog类型的数据
    
    }
    
    

    理解:结构体数组指针就是一个指针,感觉没有实际意义,可用普通指针代替。

    展开全文
  • 结构体指针和结构体嵌套

    千次阅读 2016-02-23 19:04:04
    原文 ... ...结构体指针 ...当一个指针指向一个结构体变量的时候,就叫做结构体指针,结构体指针指向结构体变量的首地址 访问成员值: #include int main(int argc, const char * argv[]) { str
  • const使用后,结构体的内容不能被修改,防止误操作。 #include<iostream> #include<string> using namespace std; //定义学生结构体 struct Student { string name; int age; int score; }; //...
  • const 常量指针 const int *p = &a; 常量指针 可以改指向,不能改指向的值 int * const p =&a; 指针常量 可以改值 int const * const p =&...结构体指针 用箭头访问结构体的成员 struct student *P;...
  • 在 计算结构体中某个元素相对结构体首字节地址的偏移量 基础上进行结构体成员指针反推该结构体变量的指针 计算结构体中某个元素相对结构体首字节地址的偏移量:...
  • const修饰的结构体和变量
  • 如果你在声明一个结构体A时,要使用一个未声明的结构体B时,该怎么办?如下: #include &lt;stdio.h&gt; typedef struct demo{  struct stu test;  const int test2;  int test3; }demo_t; struct stu...
  • 结构体:属于用户自定义的数据类型,允许用户存储不同的数据类型; 结构体定义和使用 通过结构体创建变量的方式有三种: struct 结构体名 变量名 struct 结构体名 变量名 = { 成员1,成员2...} 定义结构体时...
  • 结构体指针 结构体指针大家想必都非常清楚,我们也一直强调传参的时候使用结构体指针(占用4字节),减少对栈的压力。但是今天看linux的标准io时候。发现了localtime时间函数 返回值是一个结构体指针。当时有点懵...
  • 目录 知识点1【结构体】 知识点2【结构体数组】 知识点3【结构体嵌套结构体】 ...知识点9【const修饰结构体指针变量】 知识点10【共用体】 知识点1【结构体】 结构体中的成员空间是独立的 3种...
  • 结构体指针怎么用

    2016-11-23 09:39:33
    利用结构体指针输出同一个学生的学号 #include #include using namespace std; struct student { int ID; string name; }; int main() { student stu; student *p = &stu;//定义结构体指针,并初始化。这步...
  • C 结构体指针初始化

    千次阅读 2019-04-26 23:18:31
    原文 C 结构体指针初始化,CSDN同步发布。 转载请注明出处,谢谢! 在使用指针之前,务必要将其初始化。这个是我们最早学习 C 语言的时候,书上经常说的一个问题。在工作中,我们反而会经常忘记这条金科玉律。 本篇...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 111,901
精华内容 44,760
关键字:

const结构体指针