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

最新推荐文章于 2024-08-19 20:25:09 发布

chanxiaogang

最新推荐文章于 2024-08-19 20:25:09 发布

阅读量7.4k

点赞数 1

分类专栏： C++

C++ 专栏收录该内容

1 篇文章 1 订阅

订阅专栏

这里写图片描述

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

阿发你好第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");
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14

这里写图片描述

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

}
   
   1
2
3
4
5
6
   
   
    
    
   
   
   
   1
2
3
4
5
6

这里写图片描述

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

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

指定小数后的位数

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

}
   
   1
2
3
4
5
6
7
   
   
    
    
   
   
   
   1
2
3
4
5
6
7

这里写图片描述
输入一个长整型

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

变量的命名规则：必须是字母下划线数字的组合，可以用字母或者下划线开头，但是不能用数字开头
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;
}
   
   1
2
3
4
5
6
   
   
    
    
   
   
   
   1
2
3
4
5
6

浮点类型

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

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

单步调试

通常我们总是用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");
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14

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

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

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

这里写图片描述
在地址的框写入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
   
   1
2
   
   
    
    
   
   
   
   1
2

内存的表示

内存使用在存储计算机中的二进制数
内存的基本单元是字节，一个字节由8位二进制来表示
这里写图片描述
一个字节能够表示的范围是0~255
每个内存单元都是有地址的，地址表示的范围;00000000~FFFFFFFF;

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

变量与内存

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");
}
   
   1
2
3
4
5
6
7
8
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8

这里写图片描述
然后求一个变量的所占的字节

#include <iostream>
using namespace std;
int main()
{
    int a = 10;
    cout << sizeof(a) << endl;
    system("pause");
}
   
   1
2
3
4
5
6
7
8
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8

这里写图片描述

#include <iostream>
using namespace std;
int main()
{
    int a = 10;
    cout << &a<< endl;
    system("pause");
}
   
   1
2
3
4
5
6
7
8
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8

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

const 限制符

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

字面值常量

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

阿发你好第4章数组

数组的初始化

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

注意事项：
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;
   
   1
2
   
   
    
    
   
   
   
   1
2

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

char arr[3];
sizeof(arr);
   
   1
2
   
   
    
    
   
   
   
   1
2

多维数组

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

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

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

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

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

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

输出的结果是A
字符常量

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

字符数组

1、一般的初始化方法

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

2、特殊的初始化方法

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

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

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

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

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

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

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

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

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

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

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

举个例子：

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

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

逗号表达式

expr1,expr2,expr3
   
   1
   
   
    
    
   
   
   
   1

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

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

自增自减运算符

阿发你好第7章语句

if语句

if (expr)
    statement1
else (expr)
    staement2
   
   1
2
3
4
   
   
    
    
   
   
   
   1
2
3
4

switch语句

switch(expr)
{
case option_1:  break;
case option_2:  break;
case option_3:  break;
case option_4:  break;
}
   
   1
2
3
4
5
6
7
   
   
    
    
   
   
   
   1
2
3
4
5
6
7

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

for语句

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

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

while语句

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

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

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

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

do while 语句

do
{
statement
}while(expr1)
   
   1
2
3
4
   
   
    
    
   
   
   
   1
2
3
4

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

阿发你好第8章函数

全局变量与局部变量

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

函数的声明

#include<stdio.h>
int find_q(int a);//函数声明部分
int main(){
    return 0;
}
int find_q(int a){
statement;
}
   
   1
2
3
4
5
6
7
8
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8

参数的默认值
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;
}
   
   1
2
3
4
5
6
7
8
9
10
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10

内联函数 inline关键字

inline int max(int a, int b)
{
  return 0;
}
int main()
{
 int a=max(1,2);
}
   
   1
2
3
4
5
6
7
8
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8

函数的递归

阿发你好第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
2
3
4
5
6
7
   
   
    
    
   
   
   
   1
2
3
4
5
6
7

查看一个数组的地址，直接输入数组名就可以了
这里写图片描述
数组名称，本身就是一个内存的地址

指针的类型：
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");
}
   
   1
2
3
4
5
6
7
8
9
10
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10

这里写图片描述
这种写法值得注意：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");
}
   
   1
2
3
4
5
6
7
8
9
10
11
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11

这里写图片描述
总结：等式左边表示声明他的类型

#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");
}
   
   1
2
3
4
5
6
7
8
9
10
11
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11

也就是说通过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");
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

这里写图片描述

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

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

}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

这里写图片描述

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

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

#include <iostream>
using namespace std;
int main()
{

    int *p = 0;
    if (p)
    {
        cout << "p不是一个空指针" << endl;
    }
    system("pause");
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12

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

数组作为函数的参数

int arg(int *p, int len)
{
   int sum=0;
}
int main()
{
  int arr[]={0,1,2,3};
  int n;
  n=avg(arr,3)
}
   
   1
2
3
4
5
6
7
8
9
10
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10

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

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

#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;
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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

#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;
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

int test(const int *p, int len)
{
}
   
   1
2
3
   
   
    
    
   
   
   
   1
2
3

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

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

空指针的使用

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

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

二重指针

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

int **p=&q;
   
   1
   
   
    
    
   
   
   
   1

#include<stdio.h>
int number=0;
void set(int **p )
{
    *p=&number;
}
int main()
{
    int *p=NULL;
    set(&p);
    *p=23;
    return 0;
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13

二维数组

顺次打印这个行列式的值

#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;
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

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

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;
   
   1
2
3
4
5
6
   
   
    
    
   
   
   
   1
2
3
4
5
6

阿发你好第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中的数据赋值给b
    cout << b.name << endl;
    system("pause");
}

   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

这里写图片描述

结构体访问

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

   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

结构体作为函数的参数

这里写图片描述

结构体作为函数的返回值

这里写图片描述

匿名struct

using namespace std;
struct 
{
    char name;
    int num;
    int  phone;

} info;
int main()
{
    info.num = 1;
    cout << info.num << endl;
    system("pause");
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14

这里写图片描述
注意事项：
大括号只能用于初始化、不能直接用在赋值上

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

结构体的内存视图

struct 
{
    int id;
    char name[8];
}obj
   
   1
2
3
4
5
   
   
    
    
   
   
   
   1
2
3
4
5

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

结构体指针

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

将结构体作为函数的参数

作为传值方式

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

作为传地址的方式

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

作为函数的返回值

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

contact create（int id）
{
    contact a;
    a.id=id;
    return a;
} 
   
   1
2
3
4
5
6
   
   
    
    
   
   
   
   1
2
3
4
5
6

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

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

struct color
{
    unsigned char r;
    unsigned char g;
    unsigned char b;
};
struct object
{
    int x,y;
    color rgb
};
   
   1
2
3
4
5
6
7
8
9
10
11
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11

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


}
   
   1
2
3
4
5
6
7
   
   
    
    
   
   
   
   1
2
3
4
5
6
7

结构体紧凑的表示方式

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

传值和传地址

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

位字段 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;//添加一个指针用于指向下一个对象
}
   
   1
2
3
4
5
6
   
   
    
    
   
   
   
   1
2
3
4
5
6

初始化一个结构体数组

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

将这三个对象串联起来

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

头结点和末节点

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

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

有头链表

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

阿发你好第14章引用

struct object
{
    int value;
}
int main()
{
    object a = {1};
    object &r =a;//r相当于a的一个别名
}
   
   1
2
3
4
5
6
7
8
9
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9

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

int a=123;
int &r=a;
   
   1
2
   
   
    
    
   
   
   
   1
2

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

作为函数的参数

void test(object &r)
{
    r.value=1;
}
int main（）
{
    object a={1};
    test(a);
    return 0;
}
   
   1
2
3
4
5
6
7
8
9
10
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10

作为函数的返回值

object the_object={123};
object *test()
{
return &the_object;
}
int main()
{
    object *p=test();
    p->value=456;
    return 0;
}
   
   1
2
3
4
5
6
7
8
9
10
11
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11

阿发你好第15章

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

遍历字符串

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

字符串的比较

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

字符串的插入与删除
字符串的分割
使用数组还是指针？
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: 关闭文件
   
   1
2
3
   
   
    
    
   
   
   
   1
2
3

阿发你好第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;
}
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
   
   
    
    
   
   
   
   1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

数据的存储格式

存储char类型的整数

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

存储int型的整数

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

存取double类型的小数

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

存取结构体型数据

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

存取字符串结构

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

指针指向的对象

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
   
   
    
    
   
   
   
   1

常见的几个宏定义

1、NULL 空指针

#define NULL 0
或者
#define NULL (void*) 0
   
   1
2
3
   
   
    
    
   
   
   
   1
2
3

条件编译指令 #if … #endif

条件编译指令 #ifdef … #endif

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

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

int main(int argc, char **argv)
   
   1
   
   
    
    
   
   
   
   1

static

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

chanxiaogang

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录

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

阿发你好第2章

无符号类型

浮点类型

单步调试

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

阿发你好 第3章

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

内存的表示

变量与内存

const 限制符

字面值常量

阿发你好 第4章 数组

访问数组的元素

多维数组

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

字符数组

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

阿发你好第7章 语句

if语句

switch语句

for语句

while语句

do while 语句

阿发你好 第8章 函数

阿发你好 第9章 指针

指针的移动

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

数组作为函数的参数

空指针的使用

二重指针

阿发你好 第10章 结构体

结构体的定义和初始化

结构体的赋值：

结构体访问

结构体作为函数的参数

结构体作为函数的返回值

匿名struct

结构体的内存视图

结构体指针

将结构体作为函数的参数

作为函数的返回值

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

结构体紧凑的表示方式

传值和传地址

位字段 bit-filed

联合体union

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

阿发你好 第13章 链表

链表的构造

有头链表

阿发你好 第14章 引用

阿发你好 第15章

遍历字符串

字符串的比较

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

stdio.h

math.h

time.h

stdlib.h

stdio.h

阿发你好 第17章 文件操作

数据的存储格式

指针指向的对象

Run-Length Encoding 存储

文件的随机访问

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

extern 声明全局函数

extern 声明全局变量

多文件项目的生成

全量编译和增量编译

宏定义#define指定

常见的几个宏定义

条件编译指令 #if … #endif

条件编译指令 #ifdef … #endif

static

阿发你好第3章

阿发你好第4章数组

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

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

阿发你好第7章语句

阿发你好第8章函数

阿发你好第9章指针

阿发你好第10章结构体

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

阿发你好第13章链表

阿发你好第14章引用

阿发你好第15章

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

阿发你好第17章文件操作

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