ios学习之旅------玩转结构体

最新推荐文章于 2024-09-27 08:45:23 发布
最新推荐文章于 2024-09-27 08:45:23 发布
阅读量4.9k 收藏 1
点赞数 3
分类专栏： 变量 枚举 ios 结构体 typedef 文章标签： c ios 算法 编程 结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdzh2012/article/details/47802955
版权
ios 同时被 3 个专栏收录
5 篇文章 0 订阅
订阅专栏
变量
1 篇文章 0 订阅
订阅专栏
枚举
1 篇文章 0 订阅
订阅专栏
1.全局变量和局部变量
局部变量：
    概念：定义函数内部变量
    定义格式：变量类型 变量名称;
    作用域：从定义那一行开始到所在代码块结束
    生命周期：从代码执行到定义的哪一行开始，到其所在的代码的结束为止
    特点：相同的代码块中不可以有同名的变量
         不同的代码块中可以有同名的变量，内部的变量会覆盖外部定义的变量
全局变量：
    概念：定义在函数外部变量
    定义：变量类型 变量名称 = 值;
    声明：变量类型 变量名称;
    特点：1、不可以重复定义，但可以重复声明
         2、局部变量可以与全局变量同名，在局部变量的作用域范围内，那么局部变量会覆盖全局变量
         3、如果没有定义仅有声明，系统自动给它定义并将其初始化为0
    作用域：从定义的那一行开始，直到文件结束

    生命周期：从程序启动开始，直到程序退出才消亡

#include <stdio.h> 
 int num;//声明
int main(int argc, const char * argv[]) {    
    printf("num = %d\n",num);    
    int num = 20;
    printf("num = %d\n",num);
    {
        num = 40;
        int num = 10;
        printf("num = %d\n",num);
        num = 30;
    }
    printf("num = %d\n",num);         
    return 0;
}
2.结构体
  构造类型：由已有的数据类型构成类型
  1、数组：多个同种类型的数据构成的那么一种类型
     特点：只能存放一种数类型
  2、结构体：从来存放表示某种特定含义的一组数据
           它是对数据封装
           函数对功能封装
     好处：提高代码的可读性
          提高数据易用性
          提高代码可维护性
 
     定义结构体：
         1、定义结构类型
             struct 结构类型名称{
             成员类型 成员名称;
             ...
             };//必须加分号
         2、通过结构体类型定义结构变量
            struct 结构类型名称 结构体变量名称; 

#include <stdio.h>
int main(int argc, const char * argv[]) {

    //    int scores[] = {59,60};    
    //     int  年龄  姓名 char *  性别 char  身高 double  体重 double        
    //    int age;
    //    char sex;
    //    double height;
    //    double weight;
    //    char *name;
    //
    //    int ages[50];
    //    char sex[50];
    //    ....
    //  定义一个人结构体类型
    struct Person{
        int age;
        char sex;
        double height;
        double weight;
        char *name;
    };    
    //  int num;
    //  int * pointer;
    //  定义结构体变量
    struct Person person;    
    //  访问结构体成员
    person.age = 10;    
    person.sex = 'M'; 
    person.weight = 20.2;    
    person.height = 1.2;    
    person.name = "小明";    
    printf("age = %d,sex = %c,weight = %.2lf,height = %.2lf,name = %s\n",person.age,person.sex,person.weight,person.height,person.name);
   
    return 0;
}

3.定义结构体的多种类型 

#include <stdio.h>
/*
 第一种方式
  1、先定义结构体类型
  2、定义结构变量
 */
void test()
{
    
    struct Person{
        int age;
        double height;
    };
    
    struct Person p1;
}

/*
第二种方式
   定义结构体类型的同时定义结构变量
 */
void test1()
{
    struct Person{
        int age;
        double height;
    } p1,p2 = {20,1.75};
    
    p1 =(struct Person){10,1.2};
    
    printf("age = %d,height = %.2lf\n",p1.age,p1.height);
    
    printf("age = %d,height = %.2lf\n",p2.age,p2.height);
    //  结构体类型定义是不可以重名的
    //    struct Person{
    //        int age;
    //        double height;
    //    } p3,p4 = {20,1.75};
}
/*
第三种方式
   定义匿名的结构类型的同时定义结构体变量
 */
int main(int argc, const char * argv[]) { 
    struct{
        int age;
        char sex;
    } p1,p2 = {20,'M'};
    p1.age = 10;
    p1.sex = 'W';
    printf("age = %d,sex = %c\n",p1.age,p1.sex);
    p1 = p2;
    printf("age = %d,sex = %c\n",p1.age,p1.sex);
    //
    //    p1 = (struct) {10,'w'};
    //   1、不支持整体赋值
    //   2、结构体类型不能重复使用
    struct{
        int age;
        char sex;
    } p3,p4 = {20,'M'};   
    return 0;
}
4.结构体作用域
   在函数内部，结构类型作用域就如同局部变量一样
   在外边定义的结构体类型像全局变量的作用域
   作用域：从定义的那一行开始直到文件的结束
   注意点：结构类型不能声明
   结构体类型的作用，除了不能声明以外，其他与普通变量一样 

#include <stdio.h>
struct Person{
    int age;
    char sex;
};
int main(int argc, const char * argv[]) {  
    struct Person p2;    
    p2.sex = 's';
    p2.age = 10;    
    struct Person{
        int age;
    };  
    struct Person p = {10};
    printf("age = %d\n",p.age);  
    {
        struct Person p = {20};
        struct Monkey{
            char *name;
        };    
    }    
    return 0;
}


5.结构体数组
   结构体数组：数组元素为结构体数组
   定义结构体数组
   结构类型 数组名称[元素个数];
   数组元素的类型 数组名称[元素个数]; 

#include <stdio.h>
//一般情况下结构体类型都是定义在函数的外部
struct Dog{
    char *name;
    int age;
};
void test()
{
    //    int nums[] = {1,2,3,4};
    //    结构体如果没有初始化，它里面都是垃圾值
    //  第一种方式：向定义结构体数组然后初始化
    struct Dog dogs[5];
    dogs[0] = (struct Dog){"旺财",1};
    dogs[1].age = 1;
    dogs[1].name = "大黄";   
    //  遍历结构体数组    
    for(int i = 0;i < 5;i++)
    {
        printf("age = %d,name = %s\n",dogs[i].age,dogs[i].name);
    }
}
void test2()
{
    //  定义结构体数组的同时进行初始化
    //  如果没有显式初始化的结构体，那么这个结构体中所有成员都会被初始化为0
    struct Dog dogs[10] = {{"旺财",1},{"大黄",2},{"来福",3},{"小黑",4},{"小白",5}};
    //  计算数组的元素个数
    int len = sizeof(dogs) / sizeof(struct Dog);    
    for(int i = 0;i < len ;i++)
    {
        printf("age = %d,name = %s\n",dogs[i].age,dogs[i].name);
    }
    
}
int main(int argc, const char * argv[]) {  
//    test();
    tset2();
    return 0;
}

6.结构体与指针
   结构体指针：指向结构体的指针
   指针所指向的数据类型 * 指针变量名称;
   结构类型 * 指针变量名称; 

#include <stdio.h>
struct Student{
    char *name;//姓名
    int no;//学号
    double score;//成绩
};
int main(int argc, const char * argv[]) {   
    struct Student stu = {"大木",60,59};    
//   定义结构体指针
    struct Student *sp1;
    sp1 = &stu;
//  定义的同时进行初始化
    struct Student *sp = &stu;
//  通过指针访问结构体的成员的第一种方式
    (*sp).score = 60;    
//  第二种方式(重点)
    sp->name = "小木";
    sp->no = 59;
    printf("name = %s,no = %d,score = %.2lf\n",stu.name,stu.no,stu.score);
      
    return 0;
}

7.结构体嵌套
       一个结构体内部可以有其他类型的结构体成员
 结构体嵌套的注意点：
   1、结构体不可以嵌套自己,不能有字节这种类型的成员
   2、结构体可以嵌套自己类型的指针 

#include <stdio.h>
//定义了一个日期的结构体
struct Time{
    int hour; // HH
    int minute;//mm
    int second;//ss
};
struct Date{
    int year;
    int month;
    int day;
    struct Time time;
};
struct Employee{    
    int no;
    char name[20];
//  入职日期
//    int year;
//    int month;
//    int day;
    struct Date inDate;
//  生日
//    int birthyear;
//    int birthmonth;
//    int birthday;
    struct Date birthday;
//  离职日期
//    int goyear;
//    int gomonth;
//    int goday;
    struct Date outDate;
};
void test()
{
    struct Employee emp = {1,"大幕",{2014,10,14,{12,12,12}},{1990,10,14},{2014,11,14}};
    
    printf("no = %d,name = %s,入职日期 = %d-%d-%d %d:%d:%d\n"
           ,emp.no,emp.name,emp.inDate.year,emp.inDate.month,emp.inDate.day,
           emp.inDate.time.hour,emp.inDate.time.minute,emp.inDate.time.second);
    }
struct Person{
    char *name;
//    struct Person son;
    struct Person *son;
};
/*
 1.某班有5个学生，三门课。分别编写3个函数实现以下要求：
 （1） 求各门课的平均分；
 （2） 找出有两门以上不及格的学生，并输出其学号和不及格课程的成绩；
 （3） 找出三门课平均成绩在85-90分的学生，并输出其学号和姓名
 */
int main(int argc, const char * argv[]) {   
    struct Person father = {"father"};   
    struct Person son = {"son"};    
    father.son = &son;    
    printf("son name = %s\n",father.son->name);

    return 0;
}
8.枚举
  枚举：一个一个列举出来
  枚举作用：消除魔法数字
  使用场景：当某个东西只有那么几个取值时候就是用枚举
  定义枚举格式
     enum 枚举类型的名称{
     元素,//逗号
     ...
     };
   注意点：
   1、枚举类型定义中，所有元素都是整形常量
   2、枚举类型的本质就是整形 

#include <stdio.h>
//定义性别枚举类型
enum Sex{
     Man,
     Woman,
     Other
};

//int Man = 10;//枚举定义之后，后面不可定义与成员相同变量
void test()
{
    //  在代码中出现的这种表示特殊含义数字，我们魔法数字
    //    int sex = 0;  
    enum Sex sex;
    printf("%d\n",Man);
    int Man = 10;
    printf("%d\n",Man);  
    //    sex = 1;// 这里不能把要给数字赋值给一个枚举类型的变量，这样枚举存在的意义就没有了
    //    Man = 1;
    
}
// 可以指定枚举中每一个元素值
enum Season{
   Spring = 2,
   Summer,
   Autumn,
   Winter,
   SOther = 9
};
void PrintSeason(enum Season season)
{
    switch (season) {
        case Spring: //Case后面的值务必与枚举中成员一致，不要出现魔法数字
            printf("春季\n");
            break;
        case Summer:
            printf("夏季\n");
            break;
        case Autumn:
            printf("秋季\n");
            break;
        case Winter:
            printf("冬季\n");
            break;
        case SOther:
            printf("不是地球上季节\n");
            break;
        default:            
            break;
    }
}
int main(int argc, const char * argv[]) {
    printf("%d,%d,%d\n",Man,Woman,Other);
    printf("%d,%d,%d,%d\n",Spring,Summer,Autumn,Winter);       
    enum Season season = Summer;    
    PrintSeason(season);
    
    return 0;
}

9. typedef:
    给已有数据类型起别名   
   基本数据类型
   int char float double
   结构体
   枚举
   指针
      1、普通变量的指针
      2、结构体指针
      3、函数指针
   基本数据类型
  定义格式：typedef 已有数据类型 别名; 

#include <stdio.h>
void testBaseType()
{   
    typedef int  Int;   
    Int num = 10;   
    typedef Int Integer;    
    Integer a = 20;    
    printf("%d\n",a);   
}
/*
    给结构体类型起别名 
 */
void testStruct()
{    
//  第一种方式：先定义结构体类型再给结构体类型起别名
    struct _Person{
        int age;
        char *name;
    };    
    typedef struct _Person Person;    
    Person p1 = {10,"小红"};
    printf("age = %d,name = %s\n",p1.age,p1.name);   
// 第二种方式，定义结构体类型的同时给结构体类型起别名       
    typedef struct _Dog{
        int age;
        char *name;
    } Dog;    
    Dog dog = {1,"大黄"};    
//  第三种方式：定义匿名结构体类型的同时给结构体起一个别名   
    typedef struct{
        int age;
        char * name;
    } Cat;    
    Cat cat = {1,"tom"};   
}
//给枚举起别名
void testEnum()
{
//  1、先定义枚举类型然后给枚举起别名   
    enum _Sex{
      Man,
      Woman,
      Other
    };   
    typedef enum _Sex Sex;    
    Sex sex = Man;
//  2、定义枚举类型的同时给枚举类型起一个别名   
   typedef enum _Season{
        Spring,
        Summer
    } Season;        
    Season season = Spring;    
//  3、定义匿名枚举类型同时给枚举起一个别名   
    typedef enum {
         Cong,
         Suan,
         Jiang
    } TiaoWei;    
    TiaoWei zuoLiao = Cong; 
}
//4、指针类型
//4.1 基本数据类型的指针
void testTypedefBasicPointer()
{
    typedef  int * IntPointerType;
    int a = 10;    
    IntPointerType p = &a;   
    *p = 20;   
    printf("%d\n",a);    
}
//4.2 给结构体类型的指针起别名
void testTypedefStructPointer()
{
    typedef struct {
        char *name;
        int age;
    } Person;    
    typedef Person * PersonPointerType;    
    Person p = {"张三",10};    
    PersonPointerType pp = &p;        
    typedef struct _Cat{
        char *name;
        int age;    
    } Cat, * CatPointerType;    
    Cat cat = {"小猫",1};    
    CatPointerType catPointer = &cat;    
    printf("name = %s,age = %d\n",catPointer->name,catPointer->age);    
}
//4.3 给枚举类型的指针起别名
void testTypedefEnumPointer()
{
//  先定义枚举类型
    enum _Sex{
         Man,
        Woman,
        Other
    };    
    typedef enum _Sex * SexPointer;   
    enum _Sex sex = Man;        
    SexPointer sexPointer = &sex;    
    *sexPointer = Woman;    
    printf("%d\n",sex);    
}
//4.4 给函数指针起别名
int sum(int num1,int num2){    
    return num1 + num2;
}
int minus(int num1,int num2){    
    return num1 + num2;
}
//给函数指针起别名
//typedef 指针所指向的函数的返回值类型 (*函数指针类型别名)(所指向的函数的形参列表);
void testTypedefMethodPointer()
{   
//    int (*sumPointer)(int num1,int num2) = sum;
//    
//    int (*minusPointer)(int num1,int num2) = minus;   
    typedef  int (*MethodPointerType)(int num1,int num2);    
    MethodPointerType sumPointer = sum;    
    MethodPointerType minusPointer = minus;    
    int rs =  sumPointer(10,20);
    printf("rs = %d\n",rs);    
}
//了解
void testTypedefArrayPointer()
{
    char names[][10] = {"xtf","zbz","wf"};   
    char (*arrayPoiner)[10];   
    arrayPoiner = names;    
    typedef char (*ArrayPointerType)[10];    
    ArrayPointerType pointer = names;   
    printf("%s\n",pointer[0]);   
}
int main(int argc, const char * argv[]) {        
//
//    testBaseType();
//    testStruct();
    testTypedefBasicPointer();    
    testTypedefStructPointer();    
    testTypedefEnumPointer();    
    testTypedefMethodPointer();    
    testTypedefArrayPointer();
    return 0;
}




爱上ios
关注
专栏目录
74_iOS干货40_结构体和对象的相互转化 + block的写法 + 自定义打印
a_horse的博客
10-30 436
一，结构体和对象的相互转化  1，系统结构体 //结构体转NSValue的方法 + (NSValue *)valueWithCGPoint:(CGPoint)point; + (NSValue *)valueWithCGVector:(CGVector)vector; + (NSValue *)valueWithCGSize:(CGSize)size; + (NSValue *)valu...
C语言进阶学习,指针-字符串-结构体-枚举-内存管理
08-24
C语言进阶学习,指针-字符串-结构体-枚举-内存管理
iOS 中结构体简单使用
LGDBlog的博客
06-25 631
1、简单结构体的定义: 使用：初始化时前面要加 struct 2、结构体定义时就初始化，并用 typedef 进行声明，声明之后再使用时，就不用再前面加 struct 了 使用初始化数据，虽然加了 const，这个name还是可以改变的，改变之后还是有效的 ...
易错点：结构体类型名与变量名重名
最新发布
2302_77109193的博客
09-27 244
（1）结构体类型名：struct DList a,b,*c;其中abc均为变量名，用的是类型名定义的，是用来定义变量的。如果结构体类型DList定义时有重命名前缀typedef，则后续定义变量时，无需struct+DList来定义，直接使用DList来定义即可（下图类型名修改，同时记得成员定义前面的结构体类型也要跟着修改;该图也不用删除，放在后面作为相同名时的理解，紫色）（2）结构体类型的变量名：DNode，是DList结构体类型的变量名DNode.a;DNode-＞b是用来调用成员的。
iOS - 自定义结构体
Q_Q33757152的博客
01-03 813
我一直在模仿,还未曾超越大神们...... 新建一个类,导入#import &lt;UIKit/UIKit.h&gt;框架,创建结构体: #import &lt;UIKit/UIKit.h&gt; typedef struct { int totalCount; int bestCount; }ZJJFriends; typedef struct { int...
iOS 结构体struct就是这么简单
JWheat的博客
04-16 2802
结构体的定义// 结构体类型名 StudentScorestruct StudentScore {    int stuNo;    int stuMath;    int stuEnglish;    int stuChinese;};    // 创建stu结构体信息    struct StudentScore st1 = {1, 98, 96, 87};    // 结构体值的调用    ...
IOS 结构体
javaMov的专栏
04-17 947
IOS 结构体   //    定义结构体类型,不会分配存储空间 当一个整体由多个数据构成时，我们可以用数组来表示这个整体。 定义形式：结构体内部的元素，也就是组成成分，我们一般称为“成员”； 定义模板： struct  结构体名{ 类型名1   成员名1； 类型名2  成员名2； 。。。。。。 } 定义结构体类型，不会分配存储空间。 根据定义的结构体类型定
MELSEC-Q_L结构体编程手册（公共指令篇）
02-04
"MELSEC-Q_L结构体编程手册（公共指令篇）" MELSEC-Q_L结构体编程手册（公共指令篇）是三菱电机自动化（上海）有限公司发布的一份关于MELSEC-Q_L结构体编程的操作手册。该手册主要面向工业自动化领域，提供了MELSEC...
电子-结构体使用简单程序.rar
09-05
通过学习这个简单的结构体使用程序，开发者可以掌握如何在STM32平台上构建高效、易读的嵌入式系统，并理解结构体在硬件控制和软件抽象中的作用。同时，这也有助于提升对C语言和嵌入式系统设计的理解，为更复杂的项目...
C语言简单练习题--结构体--投票系统
01-28
C语言简单练习题--结构体--投票系统
IOS开发之路--C语言构造类型
09-04
此外，结构体的内存分配发生在变量声明时，且结构体的大小是其所有成员大小之和，考虑到内存对齐的影响。 **枚举（Enum）** 枚举类型用于定义一组命名的整数常量，便于代码的可读性。枚举的定义如下： ```c enum ...
结构体变量的初始化和使用
05-20
/*3结构体变量的初始化和使用*/ #include #include using namespace std; struct Student //学生信息结构体 { int num;//学号 char name[20];//姓名 float english;//英语 float math;//数学 float history;//历史 }; int main() { Student student={97001,"Lin Lin",80,82,89}; cout<<"学号："<<setw(7)<<student.num<<"\t\t"<<"姓名："<<setw(12)<<student.name<<endl; cout<<"英语："<<setw(4)<<student.english<<"\t" <<"数学："<<setw(4)<<student.math<<"\t" <<"历史："<<setw(4)<<student.history<<endl; }
黑马程序员 《ios零基础教程》--全局和局部变量、结构体、枚举 2014-4-2总结
u014152276的专栏
04-02 805
---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ---------------------- 前几天出差有事儿没学习，今天主要学习了复杂数据类型中的一些其他类型 一、其他数据类型 1.全局变量和局部变量 #include /* 根据变量的作用域，可以分为： 1.局部变量： 1>定义
关于结构体对齐的问题
yangbomoto的博客
09-13 341
#include&lt;stdio.h&gt; typedef struct A{ char c; short int a; int b; double d; }A; typedef struct B{ double d; A Aa; int b; short int a; c...
ios结构体语法
weixin_30677073的博客
01-06 162
转载于:https://www.cnblogs.com/supper-Ho/p/6257861.html
小白学开发（iOS）OC_ 经常使用结构体（2015-08-14）
weixin_34056162的博客
06-10 135
// //  main.m //  经常使用结构体 // //  Created by admin on 15/8/13. //  Copyright (c) 2015年 admin. All rights reserved. // #import &lt;Foundation/Foundation.h&gt; int main(int argc, ...
IOS开发笔记13-结构体
Su_tianbiao的专栏
10-27 725
1、返回指针的函数 指针作为函数的返回值 指针是可以作为函数的返回值的，不能返回局部变量的指针，因为当函数执行结束后指针变量就释放了。如果我们真的需要返回一个指针变量，那就要保证我们的函数执行完毕之后，指针指向的变量仍然存储在内存之中。那我们可以将变量创建在堆空间中，使用malloc或者calloc申请空间。或者直接声明为全局变量或者用static修饰的局部变量。 如
iOS中的常用结构体(转载)
qq_19282769的博客
01-21 316
http://blog.csdn.net/cmdkmd/article/details/11694131
iOS开发关系结构体分配空间
奋斗小青年的博客
10-24 1633
结构体内存分配问题(转) 1）sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用。 （2）终于搞懂struct结构体内存分配问题了，结构体中各个成员字节对齐遵循以下几个原则： 1.结构体每个成员相对于结构体首地址的偏移量（offset）都是（这个）成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；   例如有以下一个
C-C++结构体与枚举深入解析与应用
资源摘要信息:"第4章_选择(1)_C-C++_结构体和枚举" 在C或C++编程语言中，数据类型是构建程序...通过本章节的学习，编程者可以掌握如何定义和使用结构体以及枚举类型，从而在实际项目中更加灵活地处理复杂数据和情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值