C Programmieren: 2015

Dienstag, 20. Oktober 2015

数组的初始化

1:最基本的：int a[3] ={1,2,3}

2:数组可不可不初始化？#include<iostream>
using namespace std;
int main(){
int a [4];
cout<<a[0]<<a[1]<<a[2]<<a[3]<<endl;
return 0;
}//对于没有初始化的数组，程序自动赋一个初值；目的就是对程序的安全性做一个保护。

3：没有任何常量表达式的数组的初始化：

#include<iostream>
using namespace std;
int main(){
int a [] = {1，2，3，4};//这种是ok的，程序知道是四个元素
cout<<a[0]<<a[1]<<a[2]<<a[3]<<endl;
return 0;
}
4：数组初始化指明了大小，但是只指明了部分元素；
#include<iostream>
using namespace std;
int main(){
int a [4] = {1,2};//前面两个元素为1，2，后面的两个元素为0，0
cout<<a[0]<<a[1]<<a[2]<<a[3]<<endl;
return 0;

}

5:利用前面4的特性，就可以对数组所有元素进行0的初始化。

#include<iostream>
using namespace std;
int main(){
int a[4] = {0};//这样数组的每一个元素都初始化为0；
cout<<a[0]<<a[1]<<a[2]<<a[3]<<endl;
return 0;
}

6：当数组的元素大于数组的大小，编译错误：int a[4] ={1,2,3,4,5,6}是错误的。数组的元素小于数组的大小是允许的。

数组的定义

1数组的定义：

类型数组名 [常量表达式]

float sheep [10];
int a2001 [1000];

注意：数组的大小定义后，不能随意更改：int n = 10;
int a [n] = {0};//是不被允许的，[]中必须是常量表达式；

如果要更改数组大小，方法可以用：1：

#include<iostream>
using namespace std;
int main(){
const int i = 4;// const int i 符号常量
int a [i] = {1,2,3,4}
cout<<"a[0]="<<a[0]<<endl;
cout<<"a[1]="<<a[1]<<endl;
cout<<"a[2]="<<a[2]<<endl;
cout<<"a[3]="<<a[3]<<endl;
return 0;
}
如果发现数组大小不够用了，只需要改 i 的大小。但是并不是说定义了可变长的数组。这样可以使程序的修改变的简单一些。

2：
#include<iostream>
using namespace std;
# define N 4//预定义，表示在程序的任何地方只要碰到N就把它当做4对待
int main(){
int a [N] = {1,2,3,4};
cout<<"a[0]="<<a[0]<<endl;
cout<<"a[1]="<<a[1]<<endl;
cout<<"a[2]="<<a[2]<<endl;
cout<<"a[3]="<<a[3]<<endl;
return 0;

}

Freitag, 2. Oktober 2015

什么是链表

用指针把结构体链起来。
从数组的缺陷说起：一个是数组中所有元素的类型必须一致，第二个是数组的大小必须事先制定并且一旦指定之后不能更改。
如何解决：数组的第一个缺陷靠结构体去解决。数组的一个缺陷靠结构体去解决。结构体允许其中的元素的类型不相同，因此解决了数组的第一个缺陷。
第二个缺陷，我们希望数组的大小能够实时扩展。普通的数组显示不行。我们可以对数组进行封装以达到这种目的。我们还可以使用一个新的数据结构来解决。这个新的数据结构就是链表。几乎可以这样理解：链表就是一个元素个数可以实时变化的数组

箭头表示指针。

这样就能很容易的插入数据。

链表的形式

Donnerstag, 1. Oktober 2015

指向结构体变量的指针

# include <iostream>

using namespace std;
struct student
{
int id_num;
char name[10];
};

int main()
{
student mike = {123,{'m','i','k','e','\0'}};
student *one = &mike;
cout <<(*one).id_num<<" "<<(*one).name<<endl;
cout << one->id_num<<" "<< one->name<<endl;//前面这两种表达都一样。->是指 // 向运算符(有指针的时候用)
return 0;

}

结构体做函数返回值

#include <iostream>

using namespace std;

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

student newone()//结构体类型的函数
{
student one = {123,{'M','i','k','e','\0'}};
return one;//结构体做返回值相当于copy一份给调用者；
}

int main()
{
student mike = newone();
cout<<mike.id_num<< " " <<mike.name<<endl;
//cout<< newone()<<endl;是不可以的
return 0;

}

结构体变量做函数参数

#include<iostream>

using namespace std;

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

void renew(student one)
{
one.id_num = 20130000 + one.id_num;

for(int i = 0;one.name[i] != '\0';i++)
one.name[i] = toupper(one.name[i]);
cout << one.id_num<<" "<<one.name<<endl;
}

int main()
{
student mike = { 123,{'m','i','k','e','\0'}};
renew(mike);//把一个结构体当作变量传递给一个函数的的时候，实际是把这个 // 结构体变量所有的值都copy一份给这个函数.
cout<<mike.id_num<<" "<<mike.name<<endl;
return 0;
}

结构体变量赋值

#include<iostream>
using namespace std;

struct student
{
int id_num;
char name[10];
};//这个分号一定不要忘记
int main()
{
student mike1 = {123, {'m','i','k','e','\0'}};
student mike2;
mike2 = mike1;//把结构体变量mike1赋值给mike2;把mike1 copy一份给mike2;
mike2.id_num = 20130000 + mike2.id_num;
for(int i = 0;mike2.name[i]! = '\0';i++ )
{
mike2.name[i] = toupper(mike2.name[i]);
cout << mike1.id_num <<" "<<mike1.name<<endl;
cout << mike2.id_num<<" "<<mike2.name<<endl;
}
retrun 0;

}

Dienstag, 29. September 2015

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

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 plaincopy
 
struct stuff{  
        char job[20];  
        int age;  
        float height;  
};  

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

[cpp] view plaincopy
 
//直接带变量名Huqinwei  
struct stuff{  
        char job[20];  
        int age;  
        float height;  
}Huqinwei;  

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

[cpp] view plaincopy
 
struct stuff{  
        char job[20];  
        int age;  
        float height;  
};  
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;

Dienstag, 22. September 2015

数组与指针

#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是等价的；

Sonntag, 20. September 2015

循环的一个用法

unsigned char Num;

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

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

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

}

Samstag, 19. September 2015

数组名做函数参数

# 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;
}

Donnerstag, 17. September 2015

函数的声明的理解

#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);

Mittwoch, 16. September 2015

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后的语句。

#include <stdio.h>

int main(void){

int a;

printf("input integer number: ");

scanf("%d",&a);

switch (a){

case 1:printf("Monday\n");

case 2:printf("Tuesday\n");

case 3:printf("Wednesday\n");

case 4:printf("Thursday\n");

case 5:printf("Friday\n");

case 6:printf("Saturday\n");

case 7:printf("Sunday\n");

default:printf("error\n");

}

return 0;

}

本程序是要求输入一个数字，输出一个英文单词。但是当输入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;
}