[阿发你好]C/C++学习指南

-###———————————————————————–

阿发你好第2章

输出指定宽度的数字

#include <stdio.h>
#include <stdlib.h>
int main(){printf("number is %d\n", 3);printf("number is %d\n", 33);printf("number is %d\n", 333);printf("number is %4d\n", 3);printf("number is %4d\n", 33);printf("number is %4d\n", 333);//表示输出都是4个自出长度printf("number is %04d\n", 3);printf("number is %04d\n", 33);printf("number is %04d\n", 333);//04d表示不足四位用0补齐system("pause");
}

#include "stdio.h"
int main(){printf("x=%lf\n",1.23424);return 0;}

用变量表示小数
（我使用的IDE是kdevelop F8是编译 F9是运行）

#include "stdio.h"
int main(){double a=1.123;printf("x=%lf\n",a);return 0;
}

指定小数后的位数

#include "stdio.h"
int main(){double a=1.12334;printf("x=%.2lf\n",a);return 0;}

输入一个长整型

#include "stdio.h"
int main(){scanf("%lf",&a);return 0;
}

变量的命名规则：必须是字母下划线数字的组合，可以用字母或者下划线开头，但是不能用数字开头
char 型变量能够表示-128~127之间的整数2^7=128最高为是符号位。
long ：4字节占32位，
printf 可以输出char short int 都可以

无符号类型

unsigned char 表示的范围0~255 就是i原来2^8-1 就是255
在调用无符号整数用%u来表示
%u 在用scanf的时候，只能用unsigned int 来接收，不能用unsigned char/short

#include "stdio.h"
int main(){unsigned int a=0;scanf("%u\n",&a);return 0;
}

浮点类型

用于小数的类型有两种：double，float 类型，统称为浮点型，需要表示高的精度类型应该用double ,当精度要求不高的时候，用float类型

float a= 3.14f//这里数字后面要加一个f
scanf("%f\n",a);

单步调试

通常我们总是用F5进行编译，原来不知道有F7也可以进行生成解决方案，用F10进行单步运行。用F9进行打断点

第一次调用数组

#include <iostream>
using namespace std;
int main()
{int data[4] = { 1, 2, 3, 4 };int total=0;for (int i = 0; i <4; ++i){total += data[i];}cout << total<<endl;return 0;system("puase");
}

如何描述一下错误:
前提条件：当我输入…….的时候，
预期结果：可以正常编译
实际结果：不是我预期的效果（或者是无法正常编译）

对于测试人员：将问题进行复现，只有将问题复现才能解决

指针变量如何看他的地址：

在地址的框写入p 然后按回车就可以自动把p的地址写到这个里面

阿发你好第3章

2016/11/13

十进制、十六进制的表示方法

int a=123;//表示的10进制
int a=0x123；//表示的16进制 将这个16进制的数化成10进制的话 等于3*16^0+2*16^1+1*16^2

内存的表示

内存使用在存储计算机中的二进制数
内存的基本单元是字节，一个字节由8位二进制来表示

一个字节能够表示的范围是0~255
每个内存单元都是有地址的，地址表示的范围;00000000~FFFFFFFF;

int a=10;//10就是一个字面常量，a就是一个变量

变量与内存

char 型变量：占1个字节
short型变量：占2个字节
int 型变量：占4个字节 4 个字节（4*8=32位那么最大值：2^33-1）
float 类型占4个字节
double类型占8个字节

//用sizeof（int）可以返回出这个类型所占的字节
#include <iostream>
using namespace std;
int main()
{cout << sizeof(int) << endl;system("pause");
}

然后求一个变量的所占的字节

#include <iostream>
using namespace std;
int main()
{int a = 10;cout << sizeof(a) << endl;system("pause");
}

#include <iostream>
using namespace std;
int main()
{int a = 10;cout << &a<< endl;system("pause");
}

一个字节能够表示的范围;00~FF
在C语言中，我们用sizeof来测量一个变量或者类型的大小

const 限制符

如果一个东西，被const修饰之后，那么他就变成一个只读的常量

字面值常量

int a=1;//1 就是字面值常量，a是一个变量。

阿发你好第4章数组

数组的初始化

 char arr[4]={1,2,3,4};

注意事项：
1、char arr[3];//可以在定义的时候，不初始化初值 2、char arr[3]={1};//可以只初始化部分初值 3、char arr[]={1,2};//可以只有数值没有长度`
4、char arr[5]={0};

访问数组的元素

char arr[3];
arr[0]=1;

用sizeof（arr）来访问数组的长度

char arr[3];
sizeof(arr);

多维数组

int arr[1][2];
arr[0][0]=1;

对一个二唯数组进行初始化

int a[3][4]=
{
    {11,12,13},
    {21,22,23},
    {31,32,33},
    {41,42,43},
};

阿发你好第5章字符与字符串数组

在printf的时候我们用%c来表示字符串

char ch=65;
printf("%c",ch);

输出的结果是A
字符常量

char ch='a';
printf("%d",ch);

字符数组

1、一般的初始化方法

char str[3]={'i','l','\0'};

2、特殊的初始化方法

char str[3]="il";//最后默认添加了/0来表示数组的终止

输出字符串
用printf向程序输出字符串的话，使用格式符%s

char str[2]="I";
printf("%s\n",str);

可以使用gets来获取一个字符串

char burf[2];
gets (burf);gets()的括号里面是数组的名字
printf("%s/n",burf);

在编写字符串的时候一定要有/0来便是终止。

char str[]={'I',0};
printf("%s",str);

在输出的时候，碰到0就截止
转义字符
1、\n 换行
2、\用于输出目录
3、\t输出制表符
4、输出引号printf(“\”asdf”\”);

阿发你好第6章表达式与操作符

算数表达式
赋值表达式
关系表达式
条件表达式

expr1?expr2:expr3;
如果条件expr1为真的时候就执行expr2,否则执行expr3
这个是一个表达式

举个例子：

printf("%c\n",score>60？'T':'F');

我们都是用这条语句来简化计算的
逻辑表达式
！表示非 && 用来表示与 || 用来表示或

逗号表达式

expr1,expr2,expr3

是从逗号分开的一组表示式，从左到右依次计算，最后一个表达式为整个表示式的值

int nnn=(1,2,3);//赋值的最后结果是nnn=3

自增自减运算符

阿发你好第7章语句

if语句

if (expr)statement1
else (expr)staement2

switch语句

switch(expr)
{
case option_1:  break;
case option_2:  break;
case option_3:  break;
case option_4:  break;
}

switch 语句的注意事项：
1、switch和case的选项必须都是整型
case的选项的值必须常量

for语句

for (expr1;expr2;expr3){statement;}

在for语句中，如果存在break语句，可以直接跳出for循环
continue语句如果存在for语句大括号内，
当continue语句被执行的时候，表示结束本次循环，直接进入下一次循环

while语句

while语句也用于是实现循环，他的基本表达形式：

while (expr)//当expr为1的时候，进入循环体statement

//将编写的条件内置
int main(){int i=0;while(1){if(i>100)break;//当i=101的时候，直接跳出循环i++;
}
}

int day=2;
switch(day)
{
case 1: printf("1");
break;//如果没有break的话，程序会从匹配的入口依次往下执行
case 2:printf("2");
break;
default: printf("3");
break;
}

do while 语句

do
{
statement
}while(expr1)

首先执行statement，当while（expr）为真的的时候，返回循环，为假，跳出循环

阿发你好第8章函数

全局变量与局部变量

#include<stdio.h>
int arr[3]={0,1,2};
int main(){
printf("%d",arr[2]);
return 0;
}

函数的声明

#include<stdio.h>
int find_q(int a);//函数声明部分
int main(){return 0;
}
int find_q(int a){
statement;
}

参数的默认值
1、具有默认值的参数必须在列的最后面
2、当函数的声明与定义分来的时候，不能写在定义里面

也就是说，在声明里面添加默认值，不能写在定义里面
#include<stdio.h>
void funtion(int a, int b, int c=1);
int main(){return 0;
}
void function(int a.int b, int c)
{
return 0;
}

内联函数 inline关键字

inline int max(int a, int b)
{return 0;
}
int main()
{int a=max(1,2);
}

函数的递归

阿发你好第9章指针

指针类型用于表示地址
星号操作符号，直接用于指针变量上，直接用来读写内存值的
下面是代码`#include
using namespace std;
int main()
{
int a = 0;
int *p = &a;
*p = 0x11;//修改内存里的内容
*p = 0x12;
a=0x14;
system(“pause”);
}

&以为向下走，也就是去取地址
*相当于往上走，去地址中的内容
*p 可以用修改地址中的内容，他的效果和a修改的效果是一样
p则表示的a所在位置的地址。

#include <iostream>
using namespace std;
int main()
{int arr[4] = { 1, 2, 3, 4 };system("pause");
}

查看一个数组的地址，直接输入数组名就可以了

数组名称，本身就是一个内存的地址

指针的类型：
1、chat* ：表示一个char型变量的地址
2、short* : 表示一个short型变量的地址
3、int* : 表示一个int型变量的地址
4、float* : 表示一个float型变量的地址
5、double * ：表示一个double型变量的地址

在打印的地址的时候用%p来表示指针类型

#include <iostream>
using namespace std;
int main()
{int arr[4] = { 1, 2, 3, 4 };int *p1 = arr;int *p2 = &arr[0];//这两句是等价的system("pause");
}

这种写法值得注意：int *p=arr；

指针的移动

#include <iostream>
using namespace std;
int main()
{int arr[4] = { 1, 2, 3, 4 };int *p1 = arr;int *p2 = &arr[0];//这两句是等价的p1 += 1;cout << *p1;system("pause");
}

总结：等式左边表示声明他的类型

#include <iostream>
using namespace std;
int main()
{int arr[4] = { 1, 2, 3, 4 };int *p = &arr[1];p[0] = 0xAA;p[1] = 0xBB;return 0;system("pause");
}

也就是说通过p修改了数组arr中的元素
实例说明P修改arr中的元素

#include <iostream>
using namespace std;
int main()
{int arr[4] = { 1, 2, 3, 4 };int *p = arr;for (int i = 0; i < 4; ++i){p[i] += p[i];cout << p[i]<< endl;}for (int ii = 0; ii < 4;++ii){cout << arr[ii] << endl;}system("pause");
}

把指针作为一个函数的参数来使用

#include <iostream>
using namespace std;
void test(int *p);
int main()
{int a =0x11;test(&a);system("pause");
}
void test(int *p)
{*p=0x12;cout << "change the value:" << *p << endl;}

const int *p=&a;//也就是说明 p指针只能指向a，或者的表示只能读，不能写
int *const p=&a;//这就是说p不能被修改，而*p可以被修改

指针只能指向变量或者数组
野指针就是指的那个没有指向变量和数组的指针
**空指针**iint *p=0;

#include <iostream>
using namespace std;
int main()
{int *p = 0;if (p){cout << "p不是一个空指针" << endl;}system("pause");
}

说明输出结果就时一个空指针
也就是说，当你传入一个空指针的时候，一个函数是有办法判断他是不是一个空指针的

数组作为函数的参数

int arg(int *p, int len)
{int sum=0;
}
int main()
{int arr[]={0,1,2,3};int n;n=avg(arr,3)
}

方法1、int avg(int *p,int len)
方法2、int avg(int p[],int len)

当数组作为函数的参数的时候的引用。

#include<stdio.h>
int avg(int*p,int len )
{int sum = 0;for (int i = 0; i < len; i++){sum += p[i];}return sum ;
}
int main(){int arr[4] = { 1, 2, 3, 4 };int rect = 0;rect = avg(arr, 4);printf("%d", rect);int a;getchar();//scanf("%d\n",&a);return 0;
}

指针类型作为函数的返回值

#include <iostream>
#include <stdlib.h>
int number = 1;
int *get()
{return &number;
}
int main()
{int *p = get();//*p = 12;printf("%d\n", p);printf("%d\n", *p);system("pause");return 0;
}

const指针
在普通的指针类型上加上关键字const修饰，叫做const指针类型
const的作用封禁了信号操作里的写内存功能

int test(const int *p, int len)
{
}

const指针常用于限定函数参数
这个参数限定为const类型，用于显式地指定：“该函数是输入参数，在函数里只是读取内存的值，而不会修改这个内存的值”

void * 型指针
void * 型指针仅仅表示一个内存地址，它不指明内存里的存放何种类型的数据。
void * 型指针不支持加减法

空指针的使用

int *p=0;//空指针
if(p)//用if语句来判断指针类型是否为空值
{printf("%d\n",*p);
}

指针的使用规范：
1、杜绝野指针
当一个指针初始化的时候，要么将其置为空指针，要么将其指向为某个变量的地址
2、防止数组越界
3、目标内存是否已经生效
用一个指针指向一个变量，但是要注意这个变量的作用域。

二重指针

指针也是变量，凡是变量就是有地址

int **p=&q;

#include<stdio.h>
int number=0;
void set(int **p )
{*p=&number;
}
int main()
{int *p=NULL;set(&p);*p=23;return 0;
}

二维数组

顺次打印这个行列式的值

#include <stdlib.h>
#include <iostream>
using namespace std;
void test(int data[][4], int rows)//打印这个行列式
{for (int i = 0; i < rows;i++){for (int j = 0; j < 4;j++){printf("%d\n", data[i][j]);}}
}
int main()
{int arr[2][4] ={{ 1, 2, 3, 4 },{ 11, 12, 13, 14 }, };test(arr, 2);system("pause");return 0;
}

二维数组和指针之间的变换

int aa[6][4];
int (* row0)[4]=aa;//row0:指向第0行
int (* row1)[4]=aa;//row1:指向第1行
(*row0)[0]=1;//第一种方法：使用指针的方式，访问第0行第0列；
row0[0][1]=2;
row[0][0]=3;

阿发你好第10章结构体

结构体的定义和初始化

定义结构体数组

结构体的赋值：

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
struct Highschool
{char name;int num;int  phone;};
int main()
{Highschool a={ 'c', 1, 2 };Highschool b = a;//将a中的数据赋值给bcout << b.name << endl;system("pause");
}

结构体访问

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
struct Highschool
{char name;int num;int  phone;};
int main()
{Highschool a={ 'c', 1, 2 };Highschool *p = &a;cout << p->name << endl;//使用->箭头来访问结构体的成员变量（这是常用写法）cout<<(*p).id<<endl;system("pause");
}

结构体作为函数的参数

结构体作为函数的返回值

匿名struct

using namespace std;
struct
{char name;int num;int  phone;} info;
int main()
{info.num = 1;cout << info.num << endl;system("pause");
}

注意事项：
大括号只能用于初始化、不能直接用在赋值上

strcpy 函数用于复制字符串，在使用之前需要向其中添加#include<string.h>

结构体的内存视图

struct
{int id;char name[8];
}obj

一个obj占据12个字节，一个char是占一个字节，那么一个id是4个字节，一个name[8]占据8个字节

结构体指针

contact *p=&a;//结构体加上相应的*号就相当于对应类型的指针类型
p->id=123;//对于结构体指针类型用->来访问对象的数据成员

将结构体作为函数的参数

作为传值方式

void test(contact a)
{
printf("id is %d/n name is %s",a.id,a.name)
}

作为传地址的方式

void test(contact *a)
{
printf("id is %d/n name is %s/n",a->id, a->name);
}

作为函数的返回值

和基本的结构体一样、结构体类型也可以作为函数返回值的类型

contact create（int id）
{contact a;a.id=id;return a;
}

结构体作为结构体的成员函数

成员函数的类型也可以是结构体类型

struct color
{unsigned char r;unsigned char g;unsigned char b;
};
struct object
{int x,y;color rgb
};

object obj=
{1,2,{0xFF,0X00,0X00}}

结构体紧凑的表示方式

struct object
{
int x;
int y;
}a，*p;//在这里直接初始化两个对象，一个结构体类型的a，和一个结构体指针类型的*p

传值和传地址

传值-是说明：在传递参数的时候，如果传入对象是一个值，那么就叫做传值
传地址-是说明：在传递参数的时候，如果传入的对象是一个地址，那么就叫做传地址

位字段 bit-filed

在结构体当中有一种特殊的成员，叫做位字段。他是在变量名后面加冒号，然后标明该字段到底占用了多少个位
Struct object
{
Unsigned char a : 1;
Unsigned char b : 2;
};
表明该字段到底是占了1位，如果是1位的话，则只能取值[0,1],占了2位，取值范围[0~3],占了三位[0~7]

联合体union

Union 在实际的工程当中，一般不会使用这个语法，学这个语法的目的，只是为了读懂一种老旧的C语言代码

Union somedata
{
Unsigned int a;
Unsigned char b;
Char c[10];
}
联合体是共享同一片内存区域的

联合体的大小就是所有成员里体积最大的那个成员的大小

阿发你好第12章动态分配内存

在操作系统中，有一个内存管理器（MM），
在C语言中，内存的管理和释放用malloc/free这两个函数来调用
malloc申请内存，申请的内存在堆区（heap）
一个系统当中只有一个内存管理器，系统中所有的进程都向同一个内存管理器来申请内存。
内存泄漏：就是程序长时间运行，如果不能及时清理内存，内存积累的就会越来越多，导致系统没有内存空间可是使用，这种现象，就是内存泄漏。
对象的分类：
1、全局对象
2、局部对象
3、动态对象
一个对象就对应了一块内存，对象的值就是内存里的数据

阿发你好第13章链表

链表是一种数据的组织方式

链表的构造

struct student
{int id;char name[16];student *next;//添加一个指针用于指向下一个对象
}

初始化一个结构体数组

student ss[4]=
{{123,"123",0},{123,"123",1},{123,"123",2}
}

将这三个对象串联起来

ss[0].next=&ss[1];
ss[1].next=&ss[2];
ss[2].next=0;

头结点和末节点

//当若干个对象别串起来的时候，只需要添加第一个对象，就可以访问到链表中的每一个对象
student *p=&ss[0];
while(p)
{printf("%d,%s",p->id,p->name)p=p->next;//指向下一个对象
}

链表头的作用：链表头可以用于代表整个链表

有头链表

有一个固定的头节点来指代整个链表，所有的对象都挂在这个头节点下面，而头节点本身不包含有效数据
使用头链表的目的是，简化链表的操作使之容易实现
头部的节点称为头节点，后面的节点称为数据节点
这个部分我就先跳过了，等有机会再去写吧

阿发你好第14章引用

struct object
{int value;
}
int main()
{object a = {1};object &r =a;//r相当于a的一个别名
}

指针和引用的最大的区别在于：引用在定义的时候，必须关联到一个对象。而指针的话，不必在初始化的时候就指向一个对象，可以指向一个空指针

int a=123;
int &r=a;

object a={1};
object &r=a;
object *p=&r;

作为函数的参数

void test(object &r)
{r.value=1;
}
int main（）
{object a={1};test(a);return 0;
}

作为函数的返回值

object the_object={123};
object *test()
{
return &the_object;
}
int main()
{object *p=test();p->value=456;return 0;
}

阿发你好第15章

C风格字符串
字符串通常以3种形式存在：字符数组、动态字符串常量和字符串常量
字符串数组
并不是所有的char*都叫做字符串，实际上，只有当这块内存用于存储字符串的时候，我们才称他为字符串，如果只是把它用于存储于一些普通的数据，则不能不他称为字符串。

遍历字符串

遍历字符串，有两种方法：1、索引遍历；2、指针遍历。

字符串的比较

在<string.h>中、用strcmp函数来比较这两个字符串

字符串的插入与删除
字符串的分割
使用数组还是指针？
1、数组的方式
优点：1、安全，不必维护指针
2、操作简单
缺点：1、浪费空间
2、不适用较长的字符串

阿发你好第16章标准C语言库

标准C语言库也被称为：ANSI C 函数库

stdio.h

getchar()、putchar()//向控制台输入、输出一个字符
gets()、puts()//输入字符串、输出字符串
sprintf、sscanf()//

math.h

abs 取绝对值
ceil 向上取整
floor 向下取整
pow 求x的y次幂
sqrt 求平方根

time.h

time_t是一个typedef

stdlib.h

atoi/atof 字符串转化成数字
rand/srand 随机数生成
以及system里面的函数

stdio.h

1、fopen：打开文件
2、fwrite: 写入数据
3、fclose: 关闭文件

阿发你好第17章文件操作

#include<stdio.h>
int main()
{const char *filename="c:/aaa.txt";FILE * fp=fopen(filename,"rb");if(fp==NULL){printf("fail to open file");return -1;}char buf[123];int n=fread(buf,1,123,fp);fclose(fp);return 0;
}

数据的存储格式

存储char类型的整数

char ch=12;
fwrite(&ch,1,1,fp);//存入
fread(&ch,1,1,fp);//读取

存储int型的整数

int n=12;
fwrite(&n,1,sizeof(int),fp);//存
fread(&n,1,sizeof(int),fp);//取

存取double类型的小数

double value=23.23;
fwrite(&value,1,sizeof(value),fp);
fread(&value,1,sizeof(value),fp);

存取结构体型数据

object obj={123};
fwrite(&obj,1,sizeof(value),fp);
fread(&obj,1,sizeof(value),fp);

存取字符串结构

char name[32]="adf";
fwrite(name,1,sizeof(name),fp);
fread(name,1,sizeof(name),fp);

指针指向的对象

Run-Length Encoding 存储

RLE是一种常见的编码技术、用于存储字符串的信息
fprintf是一种按行进行格式化写入
fgets是按行进行读取

文件的随机访问

顺序访问：按照顺序访问，不能随意跳跃
随机访问：可以任意调到一个任何位置进行访问
fseek随机访问
文件的打开模式：
wb是写模式，rb是读模式

阿发你好第18章多文件项目以及编程过程

extern 声明全局函数

假设一个项目里面有A.cpp和B.cpp，我想实现在A.cpp当中调用B.cpp里定义的函数

extern 声明全局变量

extern的作用是通知编辑器，在本CPP中要用到某个符号，这个符号可能不在本cpp中定义

多文件项目的生成

C++项目生成过程主要分成2步：1、编译；2、链接
在编译阶段：cpp文件中的代码转换成中间文件

全量编译和增量编译

全量编译：将所有的CPP 文件都编译一遍
和增量编译：只对改变的量进行编译

宏定义#define指定

所有以#为开头的行都是预处理指令

#define 语法就是对他进行原文替换

常见的几个宏定义

1、NULL 空指针

#define NULL 0
或者
#define NULL (void*) 0

条件编译指令 #if … #endif

条件编译指令 #ifdef … #endif

#ifdef 表示如果对应的宏有定义，那么则相应的代码被编译
同时也可以用#undef来去除定义

#ifndef 表示的意思和 #ifdef恰好相反
也就是说，当对应的宏不存在的时候，才能编译相应的代码

int main(int argc, char **argv)

static

static 表示的是静态变量，当static修饰一个函数，称为静态函数，当static修饰一个变量的时候，称为静态变量。