记忆总结：
1. 优先级问题：
a) int i = 5;
int j = (++i) + (++i);
输出的结果为：j=14
原因：自加的优先级高于+，赋值表达式里有两个自加 编译器默认执行完优先级高的再继续进行下一步操作，故，先执行两个自加操作，然后才会执行加法。
2. 宏定义问题
宏定义里面不包含[;]
#define MAX 6
3.堆栈和静态存储区
栈：由编译器管理（自动分配释放），存放定义函数的参数值（形参。实参副本）和局部变量的值，操作方式类似数据结构中的栈（大小大概在1M-2M左右，编译器不同分配不同）
补充知识：数据结构—栈
栈的定义：仅限在表的一端进行插入和删除操作的线性表（特征：FILO LIFO）
栈的存储与实现：
顺序栈：
用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时附设指针top指向栈顶元素在顺序栈中的位置
顺序栈的定义：
const int MAXSIZE = 100; //假定预分配的栈空间最多为100个元素
typedef int ElemTyep; //假定栈元素的数据类型为整形
struct SqStack
{
ElemType elem[MAXSIZE]; //一维数组
int top; //指针top指向栈顶元素的当前位置
}
1） SqStack就是栈的顺序存储结构的类型标识符
2） 顺序栈中元素用向量存放
3） 栈底位置时固定不变的，可设置在向量两端的任意一端
4） 栈顶位置时随着进栈和出栈操作而变化的，用一个整形量top（通常称top为栈顶指针）来表示当前栈顶位
共享栈：
多个栈共享一个足够大的连续存储空间。
共享栈的定义：
共享栈是出于对空间利用的考虑，而进行的改进，使得一个栈(s0)成为两个栈但空间没有增加(假设仍为100)，原来的栈没有大的变化，在原来栈的另一端作为一个新栈(s1)的栈底，栈的增长与原来的栈相向而行。s1栈为空的条件是栈顶指示器等于100。栈为满的条件是top0加1后等于top1，表示两个栈顶指示器已经相邻没有剩余空间可供利用。其他地方都与普通栈基本相同。
链式栈结构：
类比顺序栈，但是链式栈更方便动态分配。链式栈由一个个
结点构成，每个结点包括数据域和指针域。数据域用于存储数据元素，指针域表示元素之间的关系。
堆(heap)：一般由程序员自动分配释放，若程序员不释放，程序结束时可能由OS回收。其与数据结构中的堆是两回事，分配方式类似链表。
全局区（静态存储区 static）：全局变量和静态变量的存储。初始化的全局变量和静态变量在这里。程序结束后由系统收回。
文字常量区：常量字符串存放在这里。由系统负责释放。
程序代码区：存放函数体的二进制代码
课程总结：
1. 结构体的数据对齐
用C语言写程序时需要知道是大端模式还是小端模式。 所谓的大端模式，是指数据的低位保存在内存的高地址中，而数据的高位，保存在内存的低地址中；所谓的小端模式，是指数据的低位保存在内存的低地址中，而数据的高位保存在内存的高地址中。
为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如果将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x2211中。小端模式，刚好相反，还是ox1122。我们常用的X86结构是小端模式，而KEIL C51则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。
Java、.NET大行其道的今天，C语言作为一门经典的高级语言，存在的唯一理由就是其高效、精练。随着PC硬件升级和降价，C语言由于其自身的复杂度，在开发PC应用软件时，已经很少使用。但是在开发嵌入式系统软件和操作系统时，由于普遍强调微内核，少占用空间和高效，因此，在系统开发舞台上，C语言依旧是主角。
在实际的程序开发中，为了提高数据的读取效率，在内存资源足够的情况下，一般在定义数据结构时，应该考虑四字节对齐，其原因很简单，现在的计算机多数是32位，也就是四字节。在每次读取数据时，一般都是直接读取32位的数据。有些情况下，字节对齐的数据结构，要比非对齐的数据结构占用空间少。以下分别就这两方面举例阐述。
1、充分考虑四字节对齐，可以节省存储空间
typedef struct tagAAA{
char name[10];
long sno;
char sex;
float score[4];
}AAA;
typedef struct tagBBB{
char name[10];
char sex;
long sno;
float score[4];
}BBB;
在VC下，调试，可以很容易看出来，AAA占的存储空间为36，BBB占的存储空间为32。原因很简单，在四字节对齐的情况下，按四个字节为单位分配存储空间，如果不足，会自动补充，本次分配不足以存放下面的变量时，会重新分配空间。
AAA：
|name[0]|name[1]|name[2]|name[3]|
------------------------------------
|name[4]|name[5]|name[6]|name[7]|
------------------------------------
|name[8]|name[9]| | |
----------由于剩下的两个字节不足以存放sno（long占四个字节），所以重新分配
------------------------------------
| sno |
----------long变量占四个字节，32bits
------------------------------------
|sex | 自动填充 |
----------剩余三个字节的空间，不足以重放一个float变量，因此重新分配
------------------------------------
| score[0] |
------------------------------------
| .......... |
------------------------------------
| score[3] |
------------------------------------
由此可以轻易的计算出，AAA占36个字节，同理，很容易计算出BBB占32个字节空间。
2、字节对其的情况下，可以更高效的访问
假设一个结构体的数据如下存储：
-----------------------------------------------------
| 12 | 34 | 56 | 78 | --------(A)
-----------------------------------------------------
-----------------------------------------------------
2. | XX | YY | 12 | 34 | --------(B)
-----------------------------------------------------
| 56 | 78 | XX | YY |
在A情况下，一次性读取数据成功，但是，在B情况下，需要读取数据两次，由此，可看出效率的差异。
一般情况下，字节对齐遵从系统字节数与要求的对齐字节数相比，最小原则，即：假设要求按八字节对齐，但是系统为32位系统，则按照4字节对齐。在四字节对齐时，局部会按照2字节对齐，如：
struct tagAAA
{
char a;
short b;
char c;
}AAA;
该结构体占据的空间为8字节而不是4字节，原因就是：
-----------------------------------
| a | | b |
-----------------------------------
| c | |
而不是：
------------------------------------
| a | b | c |
------------------------------------
其原因就是局部会以2字节对齐。
附：结构体数据成员对齐的意义
许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们会要求这些数据的起始地址的值是某个数k的倍数，这就是所谓的内存对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。这种强制的要求一来简化了处理器与内存之间传输系统的设计，二来可以提升读取数据的速度。比如这么一种处理器，它每次读写内存的时候都从某个8倍数的地址开始，一次读出或写入8个字节的数据，假如软件能保证double类型的数据都从8倍数地址开始，那么读或写一个double类型数据就只需要一次内存操作。否则，我们就可能需要两次内存操作才能完成这个动作，因为数据或许恰好横跨在两个符合对齐要求的8字节内存块上。
结构体对齐包括两个方面的内容
1． 结构体总长度
2． 结构体内各数据成员的内存对齐，即该数据成员相对结构体的起始位置
结构体大小的计算方法和步骤
1． 将结构体内所有数据成员的长度值相加，记为sum_a；
2． 将各数据成员为了内存对齐，按各自对齐模数而填充的字节数累加到和sum_a上，记为sum_b。对齐模数是#pragma pack指定的数值以及该数据成员自身长度中数值较小者。该数据相对起始位置应该是对齐模式的整数倍。
3． 将和sum_b向结构体模数对齐，该模数是#pragma pac指定的数值和结构体内部最大的基本数据类型成员长度中数值较小者。结构体的长度应该是该模数的整数倍。
结构体大小计算举例
在计算之前，我们首先需要明确的是各个数据成员的对齐模数，对齐模数和数据成员本身的长度以及pragma pack编译参数有关，其值是二者中最小数。如果程序没有明确指出，就需要知道编译器默认的对齐模数值。下表是Windows XP/DEV-C++和Linux/GCC中基本数据类型的长度和默认对齐模数
|
|
| char | short | int | long | double | long double |
| Windows | 长度 | 1 | 2 | 4 | 4 | 8 | 12 |
| 模数 | 1 | 2 | 4 | 4 | 8 | 4 | |
| Linux | 长度 | 1 | 2 | 4 | 4 | 8 | 12 |
| 模数 | 1 | 2 | 4 | 4 | 4 | 4 |
例子1：
struct my_struct
{
char a;
long double b;
};
此例子Windows和Linux计算方法一样，如下：
步骤1：所有数据成员自身长度和：1B + 12B = 13B，sum_a = 13B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_b = sum_a + 3 = 16B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma
pack中较小者，前者为12后者为4，所以结构体对齐模数是4。sum_b是4的4倍，不需再次对齐。
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图1所示。
例子2：
#pragma pack(2)
struct my_struct
{
char a;
long double b;
};
#pragma pack()
例子1和例子2不同之处在于例子2中使用了#pragma pack(2)编译参数，它强制指定对齐模数是2。
此例子Windows和Linux计算方法一样，如下：
步骤1：所有数据成员自身长度和：1B + 12B = 13B，sum_a = 13B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是2，之前需填充1个字节，sum_b = sum_a + 1 = 14B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma
pack中较小者，前者为12后者为2，所以结构体对齐模数是2。sum_b是2的7倍，不需再次对齐。
综上3步，可知结构体的长度是14B，各数据成员在内存中的分布如图2所示。
例子3：
struct my_struct
{
char a;
double b;
char c;
};
前两例中，数据成员在Linux和Windows下都相同，例3中double的对齐模数在Linux中是4，在Windows下是8，针对这种模数不相同的情况加以分析。
在Windows中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 8B + 1B = 10B，sum_a = 10B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充7个字节，sum_b = sum_a + 7 = 17B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为8，所以结构体对齐模数是8。sum_b应该是8的整数倍，所以要在结构体后填充8*3 - 17 = 7个字节。
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图3所示。
在Linux中计算步骤如下：
步骤1：所有数据成员自身长度和：1B + 8B + 1B = 10B，sum_a = 10B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_b = sum_a + 3 = 13B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma
pack中较小者，前者为8后者为4，所以结构体对齐模数是4。sum_b应该是4的整数倍，所以要在结构体后填充4*4 - 13 = 3个字节。
综上3步，可知结构体的长度是16B，各数据成员在内存中的分布如图4所示。
例子4：
struct my_struct
{
char a[11];
int b;
char c;
};
此例子Windows和Linux计算方法一样，如下：
步骤1：所有数据成员自身长度和：11B + 4B + 1B = 16B，sum_a = 16B
步骤2：数据成员a放在相对偏移0处，之前不需要填充字节；数据成员b为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_b = sum_a + 3 = 19B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为4后者为4，所以结构体对齐模数是4。sum_b是4的整数倍，需在结构体后填充4*5 - 19 = 1个字节。
综上3步，可知结构体的长度是20B，各数据成员在内存中的分布如图5所示。
例子5：
struct my_test
{
int my_test_a;
char my_test_b;
};
struct my_struct
{
struct my_test a;
double my_struct_a;
int my_struct_b;
char my_struct_c;
};
例子5和前几个例子均不同，在此例子中我们要计算struct my_struct的大小，而my_struct中嵌套了一个my_test结构体。这种结构体应该如何计算呢？原则是将my_test在my_struct中先展开，然后再计算，即是展开成如下结构体： struct my_struct
{ int my_test_a;
char my_test_b;
double my_struct_a;
int my_struct_b;
char my_struct_c;
};
此例子Windows中的计算方法如下：
步骤1：所有数据成员自身长度和：4B + 1B + 8B + 4B + 1B= 18B，sum_a = 18B
步骤2：数据成员my_struct_a为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是8，之前需填充3个字节，sum_b = sum_a + 3 = 21B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma pack中较小者，前者为8后者为8，所以结构体对齐模数是8。sum_b是8的整数倍，需在结构体后填充3*8 - 21 = 3个字节。
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图6所示。
此例子Linux中的计算方法如下：
步骤1：所有数据成员自身长度和：4B + 1B + 8B + 4B + 1B= 18B，sum_a = 18B
步骤2：数据成员my_struct_a为了内存对齐，根据“结构体大小的计算方法和步骤”中第二条原则，其对齐模数是4，之前需填充3个字节，sum_b = sum_a + 3 = 21B
步骤3：按照定义，结构体对齐模数是结构体内部最大数据成员长度和pragma
pack中较小者，前者为4后者为4，所以结构体对齐模数是4。sum_b是4的整数倍，需在结构体后填充6*4 - 21 = 3个字节。
综上3步，可知结构体的长度是24B，各数据成员在内存中的分布如图6所示。
2.【%】求余运算符只能进行两个整数之间的求余运算
3.自加自减运算符只能进行变量操作。：）你懂得
4.选择结构 if else操作
时间自加代码：
// 改写时间.cpp : Defines the entry point for the console application.
//用户输入年月日时分秒 系统运算给出下一秒的时间
#include "stdafx.h"
int isLespYear(int year)
{
return((year%4 == 0)&&(year%100 != 0)||(year%400) ==0);
}
int main(int argc, char* argv[])
{
while(1)
{
char *staAr[] = {"年","月","日","时","分","秒"};
int maxMon[] = {31,28,31,30,31,30,31,31,30,31,30,31}; //每个月份的最大值
int minAr[] = {0,1,1,0,0,0}; //数据下限
int maxAr[] = {99999999,12,0,23,59,59}; //数据上限
int arTemp[6] = {0,0,0,0,0,0}; //输入数据处
// 函数执行 /
for(int i = 0; i < 6; i++)
{
printf("请输入%s", staAr[i]);
scanf("%d",&arTemp[i]);
if(2==i&&isLespYear(arTemp[0]))
{
maxAr[2] = 29;
}
else
{
maxAr[2] = maxMon[arTemp[1]-1];
}
if(arTemp[i]>maxAr[i]||arTemp[i]<minAr[i])
{
printf("对不起，您输入的 %d 是不合法的,你妹啊,你见过这样的日期啊!见过啊?火星人啊?!\n重来：",arTemp[i]);
i--;
}
}
输出用户输入时间 //
printf("您输入的时间是: %4d--%2d--%2d %2d--%2d--%2d \n",arTemp[0],arTemp[1],arTemp[2],arTemp[3],arTemp[4],arTemp[5]);
执行+1操作 //
arTemp[5]++;
for(int x=5; x>0; x--)
{
if(arTemp[x]>maxAr[x])
{
arTemp[x] = minAr[x];
arTemp[x-1]++;
}
}
/ 输出操作后时间 ///
printf("您输入的时间是: %4d--%2d--%2d %2d--%2d--%2d \n",arTemp[0],arTemp[1],arTemp[2],arTemp[3],arTemp[4],arTemp[5]);
}
return 0;
}
5.循环语句
经典代码：数字金字塔
#include "stdafx.h"
#include "string.h"
void printlevel(int ipos, int icount, char cPrint, int iMishiFlag)
{
for (int i=0;i<ipos;i++)
{
putchar(' ');
}
for(int j = 0; j < icount; j++)
{
putchar(cPrint);
if(iMishiFlag)
{
putchar(' ');
}
}
putchar('\n');
}
void printtudui(int iLevel, char cPrint, int iMishFlag)
{
for(int i=0; i< iLevel; i++)
{
if(iMishFlag)
{
printlevel(iLevel - i -1,i+1,cPrint, iMishFlag);
}
else
{
printlevel(iLevel - i - 1, 2 * i + 1, cPrint , iMishFlag);
}
}
}
int main(int argc, char* argv[])
{
int iLevel = 0;
char cPrint =0;
int iMish =0;
scanf("%d",&iLevel);
scanf("%c",&cPrint);
scanf("%d",&iMish);
printtudui(iLevel, cPrint, iMish);
return 0;
}
6.数组
经典代码：给定5*5的二维int数组 满足四个角的值从左上到右下最小递增 矩阵中间的数最大
Code：
#include "stdafx.h"
#include <windows.h>
#define ROW 5
#define COL 5
void swap(int *p1, int *p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main( int argc, char **argv )
{
int aiTarget[ROW][COL] =
{
{35, 34, 33, 32, 31},
{30, 29, 28, 27, 26},
{25, 24, 23, 22, 21},
{20, 19, 18, 17, 16},
{15, 14, 13, 12, 11}
};
for(int i = 0; i < ROW; i++)
{
for (int j = 0; j < COL; j++)
{
if (aiTarget[i][j] < aiTarget[0][0])
{
swap(&aiTarget[i][j], &aiTarget[0][0]);
}
if (aiTarget[i][j] < aiTarget[0][COL - 1])
{
swap(&aiTarget[i][j], &aiTarget[0][COL - 1]);
}
if (aiTarget[i][j] < aiTarget[ROW - 1][0])
{
swap(&aiTarget[i][j], &aiTarget[ROW - 1][0]);
}
if (aiTarget[i][j] < aiTarget[ROW - 1][COL - 1])
{
swap(&aiTarget[i][j], &aiTarget[ROW - 1][COL - 1]);
}
if (aiTarget[i][j] > aiTarget[ROW / 2][COL / 2])
{
swap(&aiTarget[i][j], &aiTarget[ROW / 2][COL / 2]);
}
}
}
for(int i = 0; i < ROW; i++)
{
for (int j = 0; j < COL; j++)
{
printf ("%d\t", aiTarget[i][j]);
}
printf("\n");
}
}
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
