结构体--构造一个新的数据类型

struct student //结构体类型的定义
{
      int id;
      char name[20];
      char sex;
      int age;
      float score;
      char addr[30];
};

注意：student是数据类型，不是变量（等同于int float,char这些数据类型）是用来定义其他变量的。它属于组合数据类型；


如何定义结构体变量：

            1 直接用已声明的结构体类型定义变量名
             student        studen1,      student2;
           ( 结构体类型名)  （结构体变量名）

 对比：int a;(student 相当与 int)

            2在声明类型的同时定义变量
             struct student 
              {
                 int id;
                 char name[20];
                 char sex;
                 int age;
                 float score;
                 char addr[30];
             }yp1,yp2;

第一种：只有结构体定义

[cpp] view plain copy

 

1. struct stuff{  
2.         char job[20];  
3.         int age;  
4.         float height;  
5. };  

第二种：附加该结构体类型的“结构体变量”的初始化的结构体定义

[cpp] view plain copy

 

1. //直接带变量名Huqinwei  
2. struct stuff{  
3.         char job[20];  
4.         int age;  
5.         float height;  
6. }Huqinwei;  

也许初期看不习惯容易困惑，其实这就相当于：

[cpp] view plain copy

 

1. struct stuff{  
2.         char job[20];  
3.         int age;  
4.         float height;  
5. };  
6. struct stuff Huqinwei;  

指针和函数的小结

指针和函数：
            1：指针用做函数参数：
                1,函数拿到地址可对其所指内容进行修改；

                2，可以用const来“限制”指针的功能；

            2：指针用做函数返回值：
                1，必须确保函数返回的地址是有意义的；

                2，返回全局变量或静态局部变量；                    

什么是静态局部变量

静态局部变量：函数中的局部变量的值在函数调用结束后不消失而保留原值；
         即其占用的存储单元不释放，在下一次该函数调用时，仍可以继续          使用该变量
         用关键字static 声明， static int value1 = 20;

例子：

#include<iostream>
using namespace std;

void function()
{
  int a = 0;//动态局部变量
  static int b = 0;//静态局部变量
  a = a + 1;
  b = b + 1;
  cout << "a = "<<a<<endl;
  cout << "b = "<<b<<endl;
}

int main()
{
  for(int i = 0;i < 4;i++)
  {
      function();//每次调用函数的时候，会对变量a在开辟一片内存空间
   }             //但是b不会释放掉，所以就会累加；

}
打印出来的结果就是a=1,b=1;a=1,b=2;a=1,b=3;a=1,b=4;

返回指针值的函数

#include<iostream>
using namespace std;
int *getInt1()
{
 int value1 = 20;
 return &value1;
}

int main()
{
  int *p ;
  p = getInt1();//由于函数的返回值是value1的地址，而且变量value1是函数内的局部变                   量，当这句表达式完成了后，函数getInt1()这片内存空间就被释放掉                     了。那么p就不知道指向谁了。
  cout << *p << endl;
  return 0;
}

所以要确保返回地址的意义；（返回一个处于生命周期中的变量的地址）

#include<iostream>
using namespace std;

int value1 = 20;//要定义全局变量；
int *getInt1()
{
 return &value1;
}

int main()
{
  int *p ;
  p = getInt1();//由于定义的全局变量，p指向value1的地址，函数getInt1()释放掉后，
                //p还是指向value1的地址
  cout << *p << endl;
  return 0;
}

由于要使用全局变量必须特别小心；还有一种方法使用静态局部变量确保返回的地址的意义；

#include<iostream>
using namespace std;


int *getInt1()
{
 static int value1 = 20;//确保value1不被释放掉；
 return &value1;
}

int main()
{
  int *p ;
  p = getInt1();//由于定义的全局变量，p指向value1的地址，函数getInt1()释放掉后，
                //p还是指向value1的地址
  cout << *p << endl;
  return 0;

数组与指针

#include<isotream>
using namespace std;

int main()
{
    int a[5] = {10,11,12,13,14}
    cout<<a<<endl;//数组名代表数组首元素的地址；数组名相当于指向数组第一个元素的                     指针
    cout<<*a<<endl;
    cout<<&a[0]<<endl; //a = &a[0]
    cout<<a[0]<<endl;
}



例如：数组a[10]={1,2,3,4,5,6,7,8,9,0}
      数组名a相当于指向第一个元素a[0]的指针（&a[0]) 即 a与&a[0]等价
     （注意数组名a不是变量，是地址常量，不能给a赋值）

概念理解：指向数组的指针：int a[10];int *p;p=a;(就是指针p指向数组a)

       
       

指针++(pointer ++)的理解

*pointer++是先对pointer进行++运算。pointer里面放的是地址；

比如: int a = 0;
      int *p2 = null;
      p2 = &a;
      p2++;                    

一般理解p2++后，应该是指向了地址0x0012FF77;

实际上p2++后，应该是指向了地址0x0012FF7A；（原因:由于定义的pointer的基类型为 int，也就是pointer指向的那片区域为int型。要把这个区域看成一个整体。）

假设：iPtr当前所存地址是0x00000100;

      若iPtr指向一个整型元素（占4个字节），

      则iPtr++ 等于 iPtr + 1*4 = 0x00000100;

      若iPtr指向一个实型元素（占4个字节）;

      则iPtr++等于iPtr + 1*4 = 0x00000104;

      若iPtr++指向一个字符元素（占一个字节）;

      则iPtr++等于iPtr + 1*1 = 0x00000101;

指针变量

当然，我们也可以设置一个变量来存放变量的地址（变量的指针）

1：指针变量：专门用于存放指针（某个变量的地址）的变量；指针变量也是变量，是变量就有地址；

理解： 0x0012FF74            76               C
      ( C 的地址  )    （变量C的内容 ）       （变量名字）

现在定义一个指针变量Pointer 来存放 变量C 的地址

    0x0012FF90             0x0012FF74        Pointer
  （ Pointer的地址）  （ 指针变量Pointer的内容）  （ 指针变量的名字）
                   就是变量C 的地址

Pointer叫做指向变量c的指针变量（也就是指针变量Pointer 放的是变量c的地址） 

2：如何定义指针变量：int *pointer;(*:表示指针运算符说明pointer的类型，pointer:指针变量的名字, int 表示指针变量的基类型（基类型：指针变量指向的变量的类型，指针变量指向的那片区域的类型）) 比如上面一个列子：int *pointer中的int指的就是变量c的类型（76是int 型）


3: 如何给指针变量赋值：int c = 76;
               int *pointer;
               pointer = &c;//将变量c的地址赋值给指针变量pointer;
                       //赋值后，称指针变量指向了变量c;
(注意不能写成 pointer = c,因为pointer是存放地址的变量,所以只能存放地址)


4：指针变量的使用：可以通过指针变量访问它所指向的变量；也利用指针运算符*实现；
                   例如：int c = 76;
                       int *pointer = &c;

则*pointer为pointer所指向的存储单元的内容；这个内容指的是变量c;所以 *pointer 可以当变量c 使用。*pointer指的不是变量c的内容76；
                 
在《指针》的blog里面，cout<<*&c<<endl;和cout<<c<<endl是等价的。也就是*pointer 和变量c是等价的。（*pointer = *&c =c）    

指针变量包含两个意思：一是以存储单元编号表示的地址,一是它指向的储存单元的数据类型。  

                      

指针

1：指针就是变量地址

2:变量的三要素:1:变量的地址， 2：变量的值， 3：变量的名字；

3:变量的地址：指向该变量的指针；

4:利用取地址运算符“&”得到变量的地址；比如变量名字为c;c = 76;count<<&c<<endl打印出c的地   址；(cout<<sizeof(&c)<<endl 得到变量c地址的长度)

5:变量地址（指针）的作用：计算机通过变量的地址（指针）操作变量

6：如何通过变量的地址（指针）操作变量：可以利用指针运算符*;比如用cout<<*&c<<endl
   打印出来的就是变量的值；cout<<*&c<<endl;和cout<<c<<endl是等价的；

                 

循环的一个用法

unsigned char Num;

while(Num--)
{
   for(i = 0;i < 250;i++)
}

相当于
for(Num = 0;Num < 250;Num++){

     for(i = 0;i < 250; i++)

}

数组名 做函数参数

# include<isotream>

using namespace std;

void change(int a[])

{

 a[0] = 30; a[1] = 50; 

}
int main()
{ int a[2] = {3,5};
  change a;// a 是数组的名字它不是变量，是一个常量，是数组在内存中的地址；
          // 相当于把a的内存空间告诉了函数change.通过函数change就把a的内容           //  改变了。
  count<<a[0]<<""<<a[1]<<endl;//输出的是a[0]=30;a[1]=50
  return 0;
}

数组元素做函数参数

#include<iostream>
using namespace std;
void change(int a, int b)
{
    a = 30; b = 50;
}

int main(){
    int a[2] = {3,5}
    change(a[0],a[1]）//把数组a的内容传递给了函数change;
    cout<<a[0]<<a[1]<<endl;最后结果还是{3，5}
    return 0;
}

局部变量和全局变量

根据变量在程序中作用范围的不同， 可以将变量分为：

局部变量：

    在函数内或块内定义， 只在这个函数或块内起作用的变量；

全局变量：

    在所有函数外定义的变量，它的作用域是从定义变量的位置开始到本程序文件结束。

局部变量和全局变量的两个例子

#include<iostream>
using namespace std;

int a = 0, b = 0;//a,b 是全局变量

void exchange()
{
   int p;
   if(a<b)
   {
     p = a;a = b;b = p;  函数里面改变的也是全局变量
    }
}
int main()
{
  cin>>a>>b;//比如输入为a=3;b=5;
  exchange();
  cout<<a<<""<<b<<endl;//输出为a=5;b=3;因为改变的是全局变量
  return 0;
}


#include<iostream>
using namespace std;

int a = 0, b = 0;//a,b 是全局变量

void exchange(int a, int b)
{
   int p;
   if(a<b)
   {
     p = a;a = b;b = p;  函数里面改变的是局部变量
    }
}
int main()
{
  cin>>a>>b;//比如输入为a=3;b=5;
  exchange(a,b);
  cout<<a<<""<<b<<endl;//输出为a=3;b=5;因为全局变量不受函数exchange的影响，函数用                          完就释放了
  return 0;
}

函数的声明的理解

#include<iostream>
using namespace std;
float max(float,float)://函数的声明写在住函数的前面，因为程序是从上往下执行的。
                         先声明了，在主函数里就能知道这个东西是函数。
                         函数的声明一定要写清楚函数返回的类型（float）,函数名字                           （max）,以及参数类型（float,float）,不需要写出参数

int main()
{
    count<<max(3,4);
    return0;
}

float max (float a, float b){
   
    if(a>b)
       return a;
    else
      return b;
}

函数既可以没有返回值也可以没有参数

#include<iostream>
using namespace std;

void show() {

  count<< "Hallo world" <<endl;

}

int main(){
  show();

  return 0;


}

函数可以是没有返回值

#include <iostream>
using namespace std;
viod delay(int n){
      for(int i=0; i<n * 100000;i++)
      return;//可以不写return.前面的viod就表示函数没有返回值
}
//只用这个函数的功能（延迟功能）

int main(){
    for(int j = 0;j < 100; j++){
   
          count<<j<<endl;
    }
   
    return;

}

函数是可以没有参数的

#include <iostream>
using namspace std;

int get_int(){
    int n = 0;
    count<<" please input an integer:" << endl;
    cin>>n;
    return n;

}//这个函数就是用他的功能。

int main{
    int result = 0;
    result = get_int();
    count<<result;
    return 0;


}

函数调用的方式

以函数在程序中出现位置和形式来看函数的调用可以分为三种形式：

1：函数调用作为独立语句，例如：

     stringPrint(); 函数调用某项功能，没有返回值

2: 函数作为表达式的一部分，例如：

    number = max(numA,numB) / 2;

3: 以实参形式出现在其他函数调用中。例如：

    number = min(sum(-5,100), numC);

C语言的基本概念Switch

 switch()

1.   switch(c) 语句中 c 可以是 int, long, char, float, unsigned int 类型？

其实这个题目很基础，c应该是整型或者可以隐式转换为整型的数据，很明显不能是实型(float、double)。所以这个命题是错误的。

switch(表达式){ 
    case 常量表达式1:  语句1;
    case 常量表达式2:  语句2;
    … 
    case 常量表达式n:  语句n;
    default:  语句n+1;
}
其语义是：计算表达式的值。 并逐个与其后的常量表达式值相比较，当表达式的值与某个常量表达式的值相等时， 即执行其后的语句，然后不再进行判断，继续执行后面所有case后的语句。如表达式的值与所有case后的常量表达式均不相同时，则执行default后的语句。

1. #include <stdio.h>
2. int main(void){
3. int a;
4. printf("input integer number: ");
5. scanf("%d",&a);
6. switch (a){
7. case 1:printf("Monday\n");
8. case 2:printf("Tuesday\n");
9. case 3:printf("Wednesday\n");
10. case 4:printf("Thursday\n");
11. case 5:printf("Friday\n");
12. case 6:printf("Saturday\n");
13. case 7:printf("Sunday\n");
14. default:printf("error\n");
15. }
16. return 0;
17. }

本程序是要求输入一个数字，输出一个英文单词。但是当输入3之后，却执行了case3以及以后的所有语句，输出了Wednesday 及以后的所有单词。这当然是不希望的。为什么会出现这种情况呢?这恰恰反应了switch语句的一个特点。在switch语句中，“case 常量表达式”只相当于一个语句标号， 表达式的值和某标号相等则转向该标号执行，但不能在执行完该标号的语句后自动跳出整个switch 语句，所以出现了继续执行所有后面case语句的情况。

为了避免上述情况，C语言还提供了一种break语句，专用于跳出switch语句，break 语句只有关键字break，没有参数。在后面还将详细介绍。修改例题的程序，在每一case语句之后增加break 语句， 使每一次执行之后均可跳出switch语句，从而避免输出不应有的结果。

【例4-10】

#include <stdio.h>
int main(void){
    int a;
    printf("input integer number:    ");
    scanf("%d",&a);
    switch (a){
        case 1:printf("Monday\n");  break;
        case 2:printf("Tuesday\n");   break;
        case 3:printf("Wednesday\n");  break;
        case 4:printf("Thursday\n");  break;
        case 5:printf("Friday\n");  break;
        case 6:printf("Saturday\n");  break;
        case 7:printf("Sunday\n");  break;
        default:printf("error\n");
    }
    return 0;
}

在使用switch语句时还应注意以下几点：

1. 在case后的各常量表达式的值不能相同，否则会出现错误。
2. 在case后，允许有多个语句，可以不用{}括起来。
3. 各case和default子句的先后顺序可以变动，而不会影响程序执行结果。
4. default子句可以省略不用。