博客园_dodolook

VC++学习笔记01-糖葫芦（数组）及其游戏编程实践

2011-11-21T18:06:00Z

大家好！我们又见面啦！本来是打算一年后再写学习笔记的，结果发现，没写了之后学习效率有所降低，所以毅然决定再累也要继续多写写学习笔记呢！

糖葫芦！有点酸酸甜甜的美食，但是听说不是很干净，很久都不敢吃了！

我们知道，最初的程序员没有变量可以使用，直接和内存地址打交道，那些怪怪的地址量让人看到很心烦啊，到后来所以就有了对地址进行抽象了，所以就出现了变量。有了变量后，程序员就不再直接和地址打交道了，这样方便了很多哦！程序员的工作效率也随之提高了很多。但是很多时候，需要操作大量相同类型的数据的时候，单个变量也感觉很繁琐，比如要表示100颗糖果，就需要申请100个糖果类型的变量。有什么办法解决这一难题呢。所以就有了对相同类型的变量进行了抽象，叫数组，一般来说，这些相同类型的变量会连续的存放。

先来看一个例子：

int main(int argc, char* argv[])
{
int a, b, c, d, e, f, g;

a = 1;
b = 1;
c = a + b;
d = b + c;
e = c + d;
f = d + e;
g = e + f;

printf("%d\n%d\n%d\n%d\n%d\n%d\n%d\n",a,b,c,d,e,f,g);

return 0;
}

在这个数列中，定义了那么多个变量是不是感觉好烦的。如何要输出100000个数构成的数列那颗呢的非累死不可！所以数组的出现拯救了程序员！（因为数组是连续存储的相同类型的变量，所以数组只要记录首地址，需要访问到哪个元素了，会直接用公式计算出相应的地址值，所以数组元素的访问效率是非常高的！但是如何要删除数组中的某个中间的元素，数组为了保持数组本身的性质，需要挪动后面相应的元素，这一来计算机就要反复的读写，如果数组太大，效率必然会比较低，所以数组这种物理上的连续性也带来了其鲜明的特质。）

修正下上面的程序：

int main(int argc, char* argv[])
{
int a[7];
a[0] = 1;
a[1] = 1;

printf("%d\n%d\n", a[0], a[1]);

for (int i=2; i<7; i++)
{
a[i] = a[i-1] + a[i-2];

printf("%d\n", a[i]);
}
return 0;
}

可以发现啊，在数组的操作中经常和循环一起用，因为用循环可以很方便的进行数组的遍历哦！不过，注意数组的操作千万不要超过范围，因为超过了范围极有可能访问到垃圾值。当然不包括精心构造的越界访问！

数组的定义其实很简单啦！就是：数据类型数组名[数组长度]，那么二维数组呢，也就是后面多加一个放括弧：数据类型数组名[数组二维长度][数组一维长度];当然三维的话一次类推。一般数组应用不会超过3维的，因为数组太多，我觉得程序员自己都会搞糊涂了。

对于一维数组的应用其实比较简单了，上面的例子就是一个典型的应用，当然在以后知识越来越丰富的情况下还有会更多的应用，比如利用一位数组在堆栈区运行程序代码，进行缓冲区溢出攻击等等。

二维数组呢！仔细想想，虽然数组在内存中是连续存储的，包括二维数组，但是我们可以把连续存储的二维数组进行抽象，抽象成一个面，就像矩形一样，一个面的话，我们就可以对这个面进行一些操作，比如显示一些自己想显示的块，还可以利用显示的块可以模拟移动，喜欢玩游戏的朋友肯定一刻想到了，利用这些好玩的抽象与思考可以写出一些游戏了，比如俄罗斯方块，生命游戏等等。的确是这样，而且很多2D游戏就是这么做的。

生命游戏！为了进一步加深对于数组的操作，很有必要进行一些编程实践，程序就是要多写才顺啦！那么就拿生命游戏开刀吧！生命游戏的规程很简单的：一个５０×５０的培养盘，原来里面充满着细胞（注：全部都有细胞）细胞每次都会根据周围的细胞数量而出生或者死亡，如果周围有三个细胞，
则本细胞生，周围有二个细胞则状态不变，其他情况细胞死亡。

下面就开始写这个游戏啦！先规定一下，我们把细胞的变化次数规定在28次。好！开始行动！

int main()
{
int a[50][50], b[50][50], i, j, k, sum;//定义两个一样的数组，3个整型变量，k表示细胞变化

for (i=0; i<50; i++) //的次数，i,j定义了对数组的处理操作
{
for (j=0; j<50; j++)
{
a[i][j] = 1; //初始化操作，把细胞全部定义为1，表示细胞全部活
}
}

for (k=0; k<28; k++)
{
for (i=1; i<50; i++)
{
for (j=1; j<50; j++)
{
sum=a[i-1][j-1]+a[i-1][j]+a[i-1][j+1]+ //对数组进行抽象，用人容易理解的
a[i][j-1] +a[i][j+1]+ //方式对数组进行矩形的抽象，这样
a[i+1][j-1]+a[i+1][j]+a[i+1][j+1]; //就感觉有了上下左右之分了。
if (3==sum) //做出判断，改变细胞的状态
{
b[i][j] = 1;
}
else if (2==sum)
{
b[i][j] = a[i][j];
}
else
{
b[i][j] = 0;
}
}
}
for (i=1; i<49; i++)
{
for (j=1; j<49; j++)
{
a[i][j] = b[i][j];
}
}
}

for (i=0; i<50; i++) //输出
{
for (j=0; j<50; j++)
{
if (1==a[i][j])
{
printf("*");
}
else
{
printf("");
}
}

printf("\r\n");
}

return 0;
}

**************************************************
* * * ******* * ****** * ******* * * *
* *
* ** ** *
* * ** ** * *
** * * **
* ** ** ** ** *
** * ** * **
* * **** * *
** ****** **
** **
** **
** * ** ** * **
** * * * * **
** * * * * **
** **
* *** *** *
** **
* * * * * * * * * *
* * * * * *
* ** * * ** *
* ****** ** * * ** ****** *
** * * * * * * * * * * **
** ** ** **
** *** *** **
** *** *** **
** ** ** **
** * * * * * * * * * * **
* ****** ** * * ** ****** *
* ** * * ** *
* * * * * *
* * * * * * * * * *
** **
* *** *** *
** **
** * * * * **
** * * * * **
** * ** ** * **
** **
** **
** ****** **
* * **** * *
** * ** * **
* ** ** ** ** *
** * * **
* * ** ** * *
* ** ** *
* *
* * * ******* * ****** * ******* * * *
**************************************************

上面就是28次后的图像，很漂亮吧！有时候可能一口气写不出来，但是不要急，要从想象转化为代码需要一个过程，多练习就好啦！先在纸上画画，再慢慢的转化为相应的程序代码！多练习，保证一下子就会啦！

质数筛子！质数是很美丽的！我是听看一部电影里的对白学的，嘿嘿！既然学习了数组，那么就可以用数组来实现这个筛子，把不是质数的数一个筛走啦！我们就做10000以内的数了。首先什么是质数，质数是：只有自己本身与１两个约数的数。首先我们从数组下标2开始，然后将相应的质数的倍数挖掉就好啦！那么10000个数据就只需要进行100次变换就好啦，因为101的倍数已经超过10000了。

int main()
{
bool ss[10000];
int i, j;

for (i=0; i<10000; i++)
{
ss[10000] = true;
}

ss[0] = false;
ss[1] = false;

for (i=2; i<100; i++)
{
if (ss[i])
{
for (j=i*i; j<10000; j+=i)
{
ss[j] = false;
}
}
}

for (i=0; i<10000; i++)
{
if (ss[i])
{
printf("%d\t", i);
}
}

printf("\n");

return 0;
}

特殊的数组——字符串

字符串是一种特殊的数组，它特殊在哪里呢，这样，我们来写1个程序，在数组中放入字符组成的串看看呢！

int main()
{
char ch[20];
ch[0] = 'h';
ch[1] = 'e';
ch[2] = 'l';
ch[3] = 'l';
ch[4] = 'o';

printf("%s\r\n", ch);

return 0;
}

输出：hello烫烫烫烫烫烫烫虉
这是怎么回事呀！哦！仔细一想原来是这样，在调试版下编译器会为申请的数组全部初始化为CC,这个CC就是这个烫，然后字符串有个规则，字符串以\0结束，所以用%s输出的时候，计算机一直在找\0，所以在找到\0之前会有这么几个烫字，因为我们申请的是20个字符空间，如何巧好是申请的是5个字符空间，输出结果可能会正确哦！所以，以后程序出现了烫的输出，多半是问题出在了栈区。如果我们在上面的程序加上一个\0是不是就是正确了！当然啦！肯定正确，因为C语言字符串就是这么规定的。

字符串加密解密

以前学过位运算哦！还记得吗！现在来做个小游戏来巩固下字符串以及为运算哦！

#include <string.h>
int main()
{
char ch[20];
char jm[20]="hahahaha";
unsigned int i;

strcpy(ch,"dodolook！");

printf("没有加密之前字符串为：%s\n",ch);

for(i=0;i<strlen(ch);i++)
{
ch[i]^=jm[i];
}

printf("加密后，字符串变为：%s\n",ch);

for(i=0;i<strlen(ch);i++)
{
ch[i]^=jm[i];
}

printf("解密后，字符串还原为：%s\n",ch);

return 0;
}

这个程序可是很奇怪的哦！计算机还会响一声的哦！到底是什么原因的啊！
这种加密方式叫逐位加密，当然这种加密方式是很简单的，很容易被破解哦！到底如何破解啊！仔细想想，计算机可是大黄牛啊！不怕累的！那么下面这个密文，如何解密呢？！解密出来是什么呢！试试看啊！下次写笔记我发布解密代码啊！

螒貤腿）找殧攽！

记住啊，计算机是不怕累的牛！

永远的乌托邦——脑浊乐队live

本文链接

一年后再更新博客了

2011-10-09T07:58:00Z

大家好！每天学习的东西比较多，加上有非常多的实践，暂时更新学习笔记博客有点力不从心了！因为把博客写好一般需要4小时左右呢.所以明年这个时候再做1个回顾性的学习笔记博客了！目前主要在学习面向对象程序的设计上面，C++实现。加油哦！！！

本文链接

我也要学C语言(威力加强版)_第二章：system函数与命令行参数以及内存的查看

2011-08-17T14:09:00Z

system函数

在C语言中可以使用system函数向操作系统传递控制台命令，通过system()函数执行命令和在DOS窗口中执行命令都是一样的效果。但是WINDOWS控制台下使用的命令比起LINUX下的SHELL还是很弱的。不过一些常用的命名都还是有的，可以满足一般的操作需要。比如我们要复制1个文件到1个目录中就可以这样写代码。

#include <stdio.h>
#include <stdlib.h>
1 int main(int argc, char *argv[], char *envp[])

2 {
3 int n_system_oversee;
4
5 if (!(n_system_oversee = system("copy E:\\asm\\1.asm F:\\1.asm")))
6 {
7 system("cls");
8 printf("success!!!\r\n");
9 }
10 else
11 {
12 printf("Error, please check!!!\r\n");
13 }
14
15 return 0;
16 }

这段代码，如何你电脑里有E盘，F盘，并存E盘下有我们想要复制的源文件，如何F盘剩余空间大于此文件，那么就会成功的复制文件！

但是这样的程序没有什么实用性，因为此程序已经固定死了文件，没有通用性！为了达到通用性，我们可以这样加入命令行参数！

1 #include <stdio.h>
2 #include <stdlib.h>
3
4 int main(int argc, char *argv[], char *envp[])
5 {
6 char buffer[80];
7 sprintf(buffer, "copy %s %s", argv[1], argv[2]);
8
9 system(buffer);
10
11 return 0;
12 }

内存里的数据

1 void main()
2 {
3 int nTest = 0x87654093;
4 int nTestB = (int)&nTest;
5 float fTest = 0.0317123f;
6
7 printf("nTest=");
8 scanf("%x", nTestB);
9 printf("nTestB=");
10 scanf("%x", &nTestB);
11
12 printf("%%hello world!\r\n"
13 "nTest\t= %08xEnd\r\n"
14 "fTest\t= %08xEnd\r\n"
15 "nTestB address is %p\r\n",
16 nTest, nTestB, &nTestB); // 80;
17
18 system("pause");
19 }

这个程序显示了C语言的灵活度。你想如何解释一些数据就可以如何去解释。只要长度合适。

经典摇滚曲：get free

本文链接

我也要学C语言(威力加强版)_第一章：WINDOWS平台下CL编译器下helloworld的编写,编译与链接

2011-08-16T12:01:00Z

编辑器，编译器，调试器的选择：

在WINDOWS平台下编译C程序有很多种编译器可以选择，比如gcc,cl,intel c++等等。编辑器呢！那就更多了，但是有2个编辑器做为主要的推荐，1个是vim,1个是emacs.任选其1就好了。调试器的话，你可以选择gdb,还有vc集成开发环境的调试器。gdb别看它黑乎乎的哦！很是强大的，不过你不习惯黑乎乎的命令行界面，也可以选择一些gdb的图形前端。vc集成开发环境的调试器呢！也非常的强大，很直观。不过这2款调试器，我比较偏爱gdb.

用vim编写C语言helloworld代码：

vim的上手可以参考其帮助文档，启动vim后输入命令:help 如图：

通过这一帮助文件就可以让你很快的上手vim.当然要更好的在vim写C程序你可以参考网络上相关的windows下vim c++开发环境的搭建文献。

呵呵！下面开始在vim中写代码了!

要理解好这个程序呢！必须先要明白一个概念，就是一个程序到底是如何被编写，编译，链接和执行的，这一过程可以参考下面的图：

首先，我们刚才在VIM中编写了helloworld的源代码了，下一步就是编译了。如图：

可以看到一个cl命令后，编译器自动完成了编译链接的过程。下面结合代码一步一步的去理解这一整个过程。

第一行！很多人做事情都有自己的一个工具包！比如修电路的大叔！一般都挎着一个电工包！木匠呢，也有一个工具包，里面放着一些常用的工具。嘿嘿！那么，现在我是想在屏幕上输出helloworld!这个时候呢，我就需要1个输出包啦！所以#include<stdio.h>就表示把stdio.h文件包拿来用，<>是表示从哪里去拿。#include就是表示这里这个位置开始插入包（其实本质是复制粘帖）。嘿嘿！我明白了！stdio.h里啦就定义实现如何输出的了！其实这个stdio.h里了不是只有输出工具的，还有输入等工具！所以这里的代码其实是把所有stdio.h里面的工具包全拿过来了！（看起来有点浪费啊！唉！）。那么如何查看这一预处理后的文件呢，这里我们加入1个参数/P.就会出现1个.i的文件了，我们来看看：

嘿嘿！出来了吧！我们再打开这个.i文件看看：

#line 1 "helloworld.c"
#line 1 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#pragma once
#line 18 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 25 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#pragma pack(push,8)
#line 34 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 49 "E:\\vc6.0\\VC98\\Include\\stdio.h"
#line 50 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 57 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 66 "E:\\vc6.0\\VC98\\Include\\stdio.h"
#line 67 "E:\\vc6.0\\VC98\\Include\\stdio.h"

typedef unsigned int size_t;

#line 73 "E:\\vc6.0\\VC98\\Include\\stdio.h"

typedef unsigned short wchar_t;

#line 80 "E:\\vc6.0\\VC98\\Include\\stdio.h"

typedef wchar_t wint_t;
typedef wchar_t wctype_t;

#line 87 "E:\\vc6.0\\VC98\\Include\\stdio.h"
#line 88 "E:\\vc6.0\\VC98\\Include\\stdio.h"

typedef char * va_list;
#line 99 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 101 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 108 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 110 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 141 "E:\\vc6.0\\VC98\\Include\\stdio.h"

struct _iobuf {
char *_ptr;
int _cnt;
char *_base;
int _flag;
int _file;
int _charbuf;
int _bufsiz;
char *_tmpfname;
};
typedef struct _iobuf FILE;

#line 159 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 172 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 185 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 214 "E:\\vc6.0\\VC98\\Include\\stdio.h"
#line 215 "E:\\vc6.0\\VC98\\Include\\stdio.h"

extern FILE _iob[];
#line 222 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 232 "E:\\vc6.0\\VC98\\Include\\stdio.h"

typedef __int64 fpos_t;

#line 243 "E:\\vc6.0\\VC98\\Include\\stdio.h"
#line 244 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 247 "E:\\vc6.0\\VC98\\Include\\stdio.h"

int __cdecl _filbuf(FILE *);
int __cdecl _flsbuf(int, FILE *);

FILE * __cdecl _fsopen(const char *, const char *, int);
#line 283 "E:\\vc6.0\\VC98\\Include\\stdio.h"

void __cdecl clearerr(FILE *);
int __cdecl fclose(FILE *);
int __cdecl _fcloseall(void);

FILE * __cdecl _fdopen(int, const char *);
#line 293 "E:\\vc6.0\\VC98\\Include\\stdio.h"

int __cdecl feof(FILE *);
int __cdecl ferror(FILE *);
int __cdecl fflush(FILE *);
int __cdecl fgetc(FILE *);
int __cdecl _fgetchar(void);
int __cdecl fgetpos(FILE *, fpos_t *);
char * __cdecl fgets(char *, int, FILE *);

int __cdecl _fileno(FILE *);
#line 307 "E:\\vc6.0\\VC98\\Include\\stdio.h"

int __cdecl _flushall(void);
FILE * __cdecl fopen(const char *, const char *);
int __cdecl fprintf(FILE *, const char *, ...);
int __cdecl fputc(int, FILE *);
int __cdecl _fputchar(int);
int __cdecl fputs(const char *, FILE *);
size_t __cdecl fread(void *, size_t, size_t, FILE *);
FILE * __cdecl freopen(const char *, const char *, FILE *);
int __cdecl fscanf(FILE *, const char *, ...);
int __cdecl fsetpos(FILE *, const fpos_t *);
int __cdecl fseek(FILE *, long, int);
long __cdecl ftell(FILE *);
size_t __cdecl fwrite(const void *, size_t, size_t, FILE *);
int __cdecl getc(FILE *);
int __cdecl getchar(void);
int __cdecl _getmaxstdio(void);
char * __cdecl gets(char *);
int __cdecl _getw(FILE *);
void __cdecl perror(const char *);
int __cdecl _pclose(FILE *);
FILE * __cdecl _popen(const char *, const char *);
int __cdecl printf(const char *, ...);
int __cdecl putc(int, FILE *);
int __cdecl putchar(int);
int __cdecl puts(const char *);
int __cdecl _putw(int, FILE *);
int __cdecl remove(const char *);
int __cdecl rename(const char *, const char *);
void __cdecl rewind(FILE *);
int __cdecl _rmtmp(void);
int __cdecl scanf(const char *, ...);
void __cdecl setbuf(FILE *, char *);
int __cdecl _setmaxstdio(int);
int __cdecl setvbuf(FILE *, char *, int, size_t);
int __cdecl _snprintf(char *, size_t, const char *, ...);
int __cdecl sprintf(char *, const char *, ...);
int __cdecl sscanf(const char *, const char *, ...);
char * __cdecl _tempnam(const char *, const char *);
FILE * __cdecl tmpfile(void);
char * __cdecl tmpnam(char *);
int __cdecl ungetc(int, FILE *);
int __cdecl _unlink(const char *);
int __cdecl vfprintf(FILE *, const char *, va_list);
int __cdecl vprintf(const char *, va_list);
int __cdecl _vsnprintf(char *, size_t, const char *, va_list);
int __cdecl vsprintf(char *, const char *, va_list);

#line 363 "E:\\vc6.0\\VC98\\Include\\stdio.h"

FILE * __cdecl _wfsopen(const wchar_t *, const wchar_t *, int);
#line 369 "E:\\vc6.0\\VC98\\Include\\stdio.h"

wint_t __cdecl fgetwc(FILE *);
wint_t __cdecl _fgetwchar(void);
wint_t __cdecl fputwc(wint_t, FILE *);
wint_t __cdecl _fputwchar(wint_t);
wint_t __cdecl getwc(FILE *);
wint_t __cdecl getwchar(void);
wint_t __cdecl putwc(wint_t, FILE *);
wint_t __cdecl putwchar(wint_t);
wint_t __cdecl ungetwc(wint_t, FILE *);

wchar_t * __cdecl fgetws(wchar_t *, int, FILE *);
int __cdecl fputws(const wchar_t *, FILE *);
wchar_t * __cdecl _getws(wchar_t *);
int __cdecl _putws(const wchar_t *);

int __cdecl fwprintf(FILE *, const wchar_t *, ...);
int __cdecl wprintf(const wchar_t *, ...);
int __cdecl _snwprintf(wchar_t *, size_t, const wchar_t *, ...);
int __cdecl swprintf(wchar_t *, const wchar_t *, ...);
int __cdecl vfwprintf(FILE *, const wchar_t *, va_list);
int __cdecl vwprintf(const wchar_t *, va_list);
int __cdecl _vsnwprintf(wchar_t *, size_t, const wchar_t *, va_list);
int __cdecl vswprintf(wchar_t *, const wchar_t *, va_list);
int __cdecl fwscanf(FILE *, const wchar_t *, ...);
int __cdecl swscanf(const wchar_t *, const wchar_t *, ...);
int __cdecl wscanf(const wchar_t *, ...);

FILE * __cdecl _wfdopen(int, const wchar_t *);
FILE * __cdecl _wfopen(const wchar_t *, const wchar_t *);
FILE * __cdecl _wfreopen(const wchar_t *, const wchar_t *, FILE *);
void __cdecl _wperror(const wchar_t *);
FILE * __cdecl _wpopen(const wchar_t *, const wchar_t *);
int __cdecl _wremove(const wchar_t *);
wchar_t * __cdecl _wtempnam(const wchar_t *, const wchar_t *);
wchar_t * __cdecl _wtmpnam(wchar_t *);

#line 414 "E:\\vc6.0\\VC98\\Include\\stdio.h"
#line 415 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 418 "E:\\vc6.0\\VC98\\Include\\stdio.h"

int __cdecl fcloseall(void);
FILE * __cdecl fdopen(int, const char *);
int __cdecl fgetchar(void);
int __cdecl fileno(FILE *);
int __cdecl flushall(void);
int __cdecl fputchar(int);
int __cdecl getw(FILE *);
int __cdecl putw(int, FILE *);
int __cdecl rmtmp(void);
char * __cdecl tempnam(const char *, const char *);
int __cdecl unlink(const char *);

#line 463 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#pragma pack(pop)
#line 471 "E:\\vc6.0\\VC98\\Include\\stdio.h"

#line 473 "E:\\vc6.0\\VC98\\Include\\stdio.h"
#line 2 "helloworld.c"

void main()
{
printf("Helloworld!\n");
}

第三行！void main()，这行呢，先要说明下了！一个很特别的单词main后面还跟着个()。其实这样的形式在C语言就是表示函数，前面的int就是函数的返回值了！其实函数也就像1个工具包里的一个有生命的小工具！你给它喂点东西，比如这里喂void，而且还要让它吐出1个int类型的东西出来！嘿嘿！而且这个有生命的小工具是可以反复使用的！但是这里有点特殊！用main命名的小工具一般只用1次，因为它有个特殊的使命啊！！！它是用户的入门函数！其实呢在VC上面真正的入门函数是mainCRTStartup()，在用户入门函数main()之前到mainCRTStartup()中间呢其实已经做了好多工作了！比如有准备命令行，获得操作系统版本,IO的初始化,获得环境选项以及其字符串，全局变量的初始化，还有做了条件编译！如果是Win程序的话入口就是WinMain(),如果不是入口就是main()啦！然后main()执行完了程序才exit啦！其实main()函数是倒数第二条函数了！不过呢一般来说，程序员有操作权限的就是到了main()函数这里了！这一过程你可以打开crt0.c文件看看具体代码如下：

/***
*crt0.c - C runtime initialization routine
*
* Copyright (c) 1989-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
* This the actual startup routine for apps. It calls the user's main
* routine [w]main() or [w]WinMain after performing C Run-Time Library
* initialization.
*
* (With ifdef's, this source file also provides the source code for
* wcrt0.c, the startup routine for console apps with wide characters,
* wincrt0.c, the startup routine for Windows apps, and wwincrt0.c,
* the startup routine for Windows apps with wide characters.)
*
*******************************************************************************/

#ifdef _WIN32

#ifndef CRTDLL

#include <cruntime.h>
#include <dos.h>
#include <internal.h>
#include <stdlib.h>
#include <string.h>
#include <rterr.h>
#include <windows.h>
#include <awint.h>
#include <tchar.h>
#include <dbgint.h>

/*
* wWinMain is not yet defined in winbase.h. When it is, this should be
* removed.
*/

int
WINAPI
wWinMain(
HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPWSTR lpCmdLine,
int nShowCmd
);

#ifdef WPRFLAG
_TUCHAR * __cdecl _wwincmdln(void);
#else /* WPRFLAG */
_TUCHAR * __cdecl _wincmdln(void);
#endif /* WPRFLAG */

/*
* command line, environment, and a few other globals
*/

#ifdef WPRFLAG
wchar_t *_wcmdln; /* points to wide command line */
#else /* WPRFLAG */
char *_acmdln; /* points to command line */
#endif /* WPRFLAG */

char *_aenvptr = NULL; /* points to environment block */
wchar_t *_wenvptr = NULL; /* points to wide environment block */

void (__cdecl * _aexit_rtn)(int) = _exit; /* RT message return procedure */

static void __cdecl fast_error_exit(int); /* Error exit via ExitProcess */

/*
* _error_mode and _apptype, together, determine how error messages are
* written out.
*/
int __error_mode = _OUT_TO_DEFAULT;
#ifdef _WINMAIN_
int __app_type = _GUI_APP;
#else /* _WINMAIN_ */
int __app_type = _CONSOLE_APP;
#endif /* _WINMAIN_ */

/***
*BaseProcessStartup(PVOID Peb)
*
*Purpose:
* This routine does the C runtime initialization, calls main(), and
* then exits. It never returns.
*
*Entry:
* PVOID Peb - pointer to Win32 Process Environment Block (not used)
*
*Exit:
* This function never returns.
*
*******************************************************************************/

#ifdef _WINMAIN_

#ifdef WPRFLAG
void wWinMainCRTStartup(
#else /* WPRFLAG */
void WinMainCRTStartup(
#endif /* WPRFLAG */

#else /* _WINMAIN_ */

#ifdef WPRFLAG
void wmainCRTStartup(
#else /* WPRFLAG */
void mainCRTStartup(
#endif /* WPRFLAG */

#endif /* _WINMAIN_ */
void
)

{
int mainret;

#ifdef _WINMAIN_
_TUCHAR *lpszCommandLine;
STARTUPINFO StartupInfo;
#endif /* _WINMAIN_ */

/*
* Get the full Win32 version
*/
_osver = GetVersion();

_winminor = (_osver >> 8) & 0x00FF ;
_winmajor = _osver & 0x00FF ;
_winver = (_winmajor << 8) + _winminor;
_osver = (_osver >> 16) & 0x00FFFF ;

#ifdef _MT
if ( !_heap_init(1) ) /* initialize heap */
#else /* _MT */
if ( !_heap_init(0) ) /* initialize heap */
#endif /* _MT */
fast_error_exit(_RT_HEAPINIT); /* write message and die */

#ifdef _MT
if( !_mtinit() ) /* initialize multi-thread */
fast_error_exit(_RT_THREAD); /* write message and die */
#endif /* _MT */

/*
* Guard the remainder of the initialization code and the call
* to user's main, or WinMain, function in a __try/__except
* statement.
*/

__try {

_ioinit(); /* initialize lowio */

#ifdef WPRFLAG
/* get wide cmd line info */
_wcmdln = (wchar_t *)__crtGetCommandLineW();

/* get wide environ info */
_wenvptr = (wchar_t *)__crtGetEnvironmentStringsW();

_wsetargv();
_wsetenvp();
#else /* WPRFLAG */
/* get cmd line info */
_acmdln = (char *)GetCommandLineA();

/* get environ info */
_aenvptr = (char *)__crtGetEnvironmentStringsA();

_setargv();
_setenvp();
#endif /* WPRFLAG */

_cinit(); /* do C data initialize */

#ifdef _WINMAIN_

StartupInfo.dwFlags = 0;
GetStartupInfo( &StartupInfo );

#ifdef WPRFLAG
lpszCommandLine = _wwincmdln();
mainret = wWinMain(
#else /* WPRFLAG */
lpszCommandLine = _wincmdln();
mainret = WinMain(
#endif /* WPRFLAG */
GetModuleHandleA(NULL),
NULL,
lpszCommandLine,
StartupInfo.dwFlags & STARTF_USESHOWWINDOW
? StartupInfo.wShowWindow
: SW_SHOWDEFAULT
);
#else /* _WINMAIN_ */

#ifdef WPRFLAG
__winitenv = _wenviron;
mainret = wmain(__argc, __wargv, _wenviron);
#else /* WPRFLAG */
__initenv = _environ;
mainret = main(__argc, __argv, _environ);
#endif /* WPRFLAG */

#endif /* _WINMAIN_ */
exit(mainret);
}
__except ( _XcptFilter(GetExceptionCode(), GetExceptionInformation()) )
{
/*
* Should never reach here
*/
_exit( GetExceptionCode() );

} /* end of try - except */

}

/***
*_amsg_exit(rterrnum) - Fast exit fatal errors
*
*Purpose:
* Exit the program with error code of 255 and appropriate error
* message.
*
*Entry:
* int rterrnum - error message number (amsg_exit only).
*
*Exit:
* Calls exit() (for integer divide-by-0) or _exit() indirectly
* through _aexit_rtn [amsg_exit].
* For multi-thread: calls _exit() function
*
*Exceptions:
*
*******************************************************************************/

void __cdecl _amsg_exit (
int rterrnum
)
{
#ifdef _WINMAIN_
if ( __error_mode == _OUT_TO_STDERR )
#else /* _WINMAIN_ */
if ( __error_mode != _OUT_TO_MSGBOX )
#endif /* _WINMAIN_ */
_FF_MSGBANNER(); /* write run-time error banner */

_NMSG_WRITE(rterrnum); /* write message */
_aexit_rtn(255); /* normally _exit(255) */
}

/***
*fast_error_exit(rterrnum) - Faster exit fatal errors
*
*Purpose:
* Exit the process with error code of 255 and appropriate error
* message.
*
*Entry:
* int rterrnum - error message number (amsg_exit only).
*
*Exit:
* Calls ExitProcess.
*
*Exceptions:
*
*******************************************************************************/

static void __cdecl fast_error_exit (
int rterrnum
)
{
#ifdef _WINMAIN_
if ( __error_mode == _OUT_TO_STDERR )
#else /* _WINMAIN_ */
if ( __error_mode != _OUT_TO_MSGBOX )
#endif /* _WINMAIN_ */
_FF_MSGBANNER(); /* write run-time error banner */

_NMSG_WRITE(rterrnum); /* write message */
ExitProcess(255); /* normally _exit(255) */
}

#ifndef WPRFLAG

#endif /* WPRFLAG */

#endif /* CRTDLL */

#else /* _WIN32 */

#include <cruntime.h>
#include <internal.h>
#include <stdlib.h>
#include <msdos.h>
#include <string.h>
#include <setjmp.h>
#include <dbgint.h>
#include <macos\types.h>
#include <macos\segload.h>
#include <macos\gestalte.h>
#include <macos\osutils.h>
#include <macos\traps.h>
#include <mpw.h>

static void __cdecl Inherit(void); /* local function */

int __cdecl main(int, char **, char **); /*generated by compiler*/

unsigned long _GetShellStack(void);

static char * __cdecl _p2cstr_internal ( unsigned char * str );

extern MPWBLOCK * _pMPWBlock;
extern int __argc;
extern char **__argv;

/***
*__crt0()
*
*Purpose:
* This routine does the C runtime initialization, calls main(), and
* then exits. It never returns.
*
*Entry:
*
*Exit:
* This function never returns.
*
*******************************************************************************/

void __cdecl __crt0 (
)
{
int mainret;
char szPgmName[32];
char *pArg;
char *argv[2];

#ifndef _M_MPPC
void *pv;

/* This is the magic stuff that MPW tools do to get info from MPW*/

pv = (void *)*(int *)0x316;
if (pv != NULL && !((int)pv & 1) && *(int *)pv == 'MPGM') {
pv = (void *)*++(int *)pv;
if (pv != NULL && *(short *)pv == 'SH') {
_pMPWBlock = (MPWBLOCK *)pv;
}
}

#endif /* _M_MPPC */

_environ = NULL;
if (_pMPWBlock == NULL) {
__argc = 1;
memcpy(szPgmName, (char *)0x910, sizeof(szPgmName));
pArg = _p2cstr_internal(szPgmName);
argv[0] = pArg;
argv[1] = NULL;
__argv = argv;

#ifndef _M_MPPC
_shellStack = 0; /* force ExitToShell */
#endif /* _M_MPPC */
}
#ifndef _M_MPPC
else {
_shellStack = _GetShellStack(); //return current a6, or first a6
_shellStack += 4; //a6 + 4 is the stack pointer we want
__argc = _pMPWBlock->argc;
__argv = _pMPWBlock->argv;

Inherit(); /* Inherit file handles - env is set up by _envinit if needed */
}
#endif /* _M_MPPC */

/*
* call run time initializer
*/
__cinit();

mainret = main(__argc, __argv, _environ);
exit(mainret);
}

#ifndef _M_MPPC
/***
*Inherit() - obtain and process info on inherited file handles.
*
*Purpose:
*
* Locates and interprets MPW std files. For files we just save the
* file handles. For the console we save the device table address so
* we can do console I/O. In the latter case, FDEV is set in the _osfile
* array.
*
*Entry:
* Address of MPW param table
*
*Exit:
* No return value.
*
*Exceptions:
*
*******************************************************************************/

static void __cdecl Inherit (
void
)
{
MPWFILE *pFile;
int i;
pFile = _pMPWBlock->pFile;
if (pFile == NULL) {
return;
}
for (i = 0; i < 3; i++) {
switch ((pFile->pDevice)->name) {
case 'ECON':
_osfile[i] |= FDEV | FOPEN;
_osfhnd[i] = (int)pFile;
break;

case 'FSYS':
_osfile[i] |= FOPEN;
_osfhnd[i] = (*(pFile->ppFInfo))->ioRefNum;
break;
}
pFile++;
}
}

#endif /* _M_MPPC */

static char * __cdecl _p2cstr_internal (
unsigned char * str
)
{
unsigned char *pchSrc;
unsigned char *pchDst;
int cch;

if ( str && *str ) {
pchDst = str;
pchSrc = str + 1;

for ( cch=*pchDst; cch; --cch ) {
*pchDst++ = *pchSrc++;
}

*pchDst = '\0';
}

return( str );
}

#endif /* _WIN32 */

第四行和第六行！诶！为什么这两行要一起学啊！因为这两行只有2个括号！哈哈！在C语言中呢1对括号就代表1个代码块了！就像python的缩进了！（应该是这样吧！以后学多了或许有新感悟的！暂时就这样理解吧！）

第五行！这一行呢其实就是从stdio.h中取出printf输出这个小工具(函数)了，然后用这个工具在屏幕上打印helloworld!字符串了！哦！很神奇！这个工具好啊！但是目前鉴于自己的水平，还不能很好的解释printf的实现，以后再解释了！

关于cl的命令行参数可以参考msdn,上面有详细的参数帮助目录。

摇滚经典曲子：Paramore - Warped Tour 2011 - Carefu

本文链接

我也要学python-内置数据结构（一）

2011-07-21T10:07:00Z

学完了C后，现在学python感觉好有效率的啊！PYTHON语言本身就内置了好多非常常用的数据结构，开发效率太高了，我在学python的时候一直在想，这个方法用C如何实现啊，然后自己再用C去实现，这样学感觉特有趣，也特有效率。都快忍不住要去悄悄PYTHON的源码啦！

关于python的学习笔记我是这样安排的：

内置数据结构（一二）
模块与函数
字符串与正则表达式
文件的处理
面向对象编程
程序调试、数据库编程、WxPython库

WxPython库中的基本控件
菜单、窗口与对话框
WxPython库中的高级控件
WxPython学生信息管理系统的实现

一共2个星期学完，呵呵，最后写个PYTHON wx版的学生信息管理系统，因为之前用C写过啦！很有信心哦！

元组

元组是一组不可修改的元素的集合

元组代码：

解释输出为：

元组的只读性：

元素的遍历：

列表

列表也是一组元素的集合，它不同与于元组的是，列表中的元素是可以修改的。

代码：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

#定义一个列表
list = ["apple", "banana", "grape", "orange"]
#直接输出列表
print list
#得到第3个元素
print list[2]
#append是加在列表的最后面
list.append("watermelon")
#在第二个元素后面插入
list.insert(1, "grapefruit")
#再次输出
print list
#删除1个元素
list.remove("grape")
print list
#如果这里去掉注释会出错，因为字符串a并不存在列表里，删除一个不存在的元素时会提示错误！
#list.remove("a")
#弹出列表最后1个元素
print list.pop()
print list

list = ["apple", "banana", "grape", "orange"]
#对列表进行分片操作，和对元素分片类试
print list[-2]
print list[1:3]
print list[-3:-1]
#定义一个二元列表
list = [["apple", "banana"], ["grape", "orange"], ["watermelon"], ["grapefruit"]]
#遍历
for i in range(len(list)):
print "list[%d] :" % i, "" ,
for j in range(len(list[i])):
print list[i][j], "" ,
print

解释输出为：

---------- python ----------
['apple', 'banana', 'grape', 'orange']
grape
['apple', 'grapefruit', 'banana', 'grape', 'orange', 'watermelon']
['apple', 'grapefruit', 'banana', 'orange', 'watermelon']
watermelon
['apple', 'grapefruit', 'banana', 'orange']
grape
['banana', 'grape']
['banana', 'grape']
list[0] : apple banana
list[1] : grape orange
list[2] : watermelon
list[3] : grapefruit

输出完成 (耗时 0 秒) - 正常终止

FOR IN 循环放入列表里：

这是列表不同于元组的特殊用法，呵呵！

列表的查找，排序与反转：

代码与注释：

#!/usr/bin/python
# -*- coding: UTF-8 -*-

list = ["apple", "grape", "grape", "orange"]
list.remove("grape")
print list

list = ["apple", "banana", "grape", "orange"]
#通过元素取索引
print list.index("grape")
print list.index("orange")
#判断某元素是否在列表里面
print "orange" in list

list1 = ["apple", "banana"]
list2 = ["grape", "orange"]
#扩展列表
list1.extend(list2)
print list1
list3 = ["watermelon"]
#列表的加法操作
list1 = list1 + list3
print list1
#扩展列表
list1 += ["grapefruit"]
print list1
#进行复制操作
list1 = ["apple", "banana"] * 2
print list1

#使用列表的sort方法排序
list = ["banana", "apple", "orange", "grape"]
#首字母升序进行排序
list.sort()
print "sorted list:", list
#反转操作
list.reverse()
print "Reversed list:", list

#使用函数sorted排序，返回一个新的列表
list = ["banana", "apple", "orange", "grape", "apple"]
#set重复数据进行过虑并排序
for li in sorted(set(list)):
print li, "" ,

解释输出：

---------- python ----------
['apple', 'grape', 'orange']
2
3
True
['apple', 'banana', 'grape', 'orange']
['apple', 'banana', 'grape', 'orange', 'watermelon']
['apple', 'banana', 'grape', 'orange', 'watermelon', 'grapefruit']
['apple', 'banana', 'apple', 'banana']
sorted list: ['apple', 'banana', 'grape', 'orange']
Reversed list: ['orange', 'grape', 'banana', 'apple']
apple banana grape orange

输出完成 (耗时 0 秒) - 正常终止

堆栈队列的实现

数据结构中堆栈和队列是一些很常见的线性结构哦！我以前学过C的实现它，现在来看看PYTHON的实现呀！

代码：

疯狂的写代码，疯狂的热爱吧！呵呵！

The Connells 传奇单曲7475

[hjp2=500,375,true]http://player.youku.com/player.php/sid/XNjIwMTQ0NjQ=/v.swf[/hjp2]

本文链接

我也要学C++_第三章：字符串

2011-07-17T10:58:00Z

在征服编程艺术的同时，也可以多方面的涉及其他艺术形式哦！人的快乐在于情感，情感的表达就成了艺术。现在起，每次学习笔记末尾我都推荐一首曲子，当时都是经典的哦！让大家每天的快乐都能再增添1分！（今天是华人乐手的骄傲：李康敏）

字符串

在上次的学习笔记中，我已经用过字符串啦！用引号括起来然后输出就好了！但是感觉这么办比较单调，有没有办法让字符串更加丰富多彩一点呢？！下面就有这么一个例子：

这段代码从cout << 知道是输出，\n我也知道，是换行，中间有个\t我在学C的时候就知道了，这个是制表符。这样的话，我就可以很顺利的猜测出程序运行的结果了。结果是：
ShapeSides

----- -----

Square　 4

Circle ?

看看正确的结果，看是不是一样的，呵呵！

呵呵！一模一样的。

如果在字符串中打印双引号呢？！

我尝试着写出代码：std::cout << "\"\n;完全正确！反斜杠可以将一个特殊字符变成正常字符。

以为会出错的代码：

这段代码，我原以为会出错呢！因为在第11行的结束，第12行的开始我没有写输出操作符呢！结果仍然是输出心中的那个正确的结果：

咦！这就奇怪了啊！哦！原来是这样的，在通常情况下我们用输出操作符分隔每个输出项，但是只要有两个以上相邻的字符串，编译器就会自动将它们结合成一个字符串。但是记住哦，这个技巧只适合于字符串，不适用于字符哦！我去看看用于字符是什么结果：

所以在输出字符串的时候，你可以选择多种风格，都可以输出同样的结果，具体怎么去选择风格就看自己了，但是最好一直保持一种风格到底哦！

这里又有一个问题，为什么不这样写呢，用一个大字符串把数字也包进去啊，比如这样：

这样看起来更简介一些啊!但是仔细一想这样也会出现一个问题，如果我事先不知道名称和边数的话就麻烦了，因为在不知道的情况下极有可能是读取存储在变量中的值，例如这样的代码：

嘿嘿！不错！C++的字符串已经内建了啊，不用像C，没有内建这个类型，不过C用字符串也非常好办。这里用到了字符串String这个类型，所以上面要包含string这个头文件了，因为你不实现告诉编译器我要用string，编译器没有心理准备，一看见string就有点紧张，接受不了啊！就像不知道自己暗恋的人会路过这个路口，结果在毫无准备的情况下在路口碰见了就有点紧张，不知所措呀！

在上面那个程序中，给字符串赋了值"Triangle"。那么怎么赋空值呢，我先想想，空的话，有几个思路：1，括号里就写个双引号，里面是空的，嘻嘻！2，括号都不要，直接申请就得了，3，直接给NULL。int sides我也什么值都不给！先去试试看：。。。。。。结果：字符串的1，2的思路都达到了目的，3直接给NULL是不行的。另外，int sides不初始化出来的值是随机值。那么怎么写才是最保险安全的写法呢？！就是下面这样写：

std::string empty("");
int zero(0);

我得好好记住啊！以后我要改正1个习惯，我以后在初始化每个变量，即使我知道程序很快就会重写它，比如我以前代码中的输入循环。

来自伦敦的龙之力量：（风格：速度金属）

[hjp2=500,375,true]http://player.youku.com/player.php/sid/XMjQ0MjUxOTU2/v.swf[/hjp2]

本文链接

我也要学C++_第二章：整数表达式

2011-07-15T04:49:00Z

上章回顾

C++的学习终于开了个头，内心是无比兴奋的，上章节我学习定义一些变量，然后对这些变量进行一些简单的操作，以及一些这些简单操作连带的一些结构控制，编译差错基本方法。在这章中，我将学习最基础的算术操作符。

阅读代码

这段代码是什么意思呢？！我一行一行的来读了：

第8-9行：我将变量sum,count的值初始化为0。在变量后边跟个括号，里面可以写上任何1个所声明变量类型的值，而且这个值也可以不是常量。如果不想初始化变量的值则必须删除小括号哦！

第10行：声明了变量X，这里为什么我没有进行初始化呢，因为后面有std::cin >> x.一般来说，声明了1个变量应该为其初始化。因为不初始化的值可能是垃圾值，所以不安全。不过这里是安全的。

第14-15行：使用了加法和赋值。我知道1个INT型的变量是有大小的，如果这里输入的值造成溢出了怎么办，这个问题我暂且不考虑。

第18行：输出你所输入值的平均值。

我尝试运行此程序：

不错！这个结果就是我所期待的结果，嘿嘿！但是如果我们什么都不输入，直接键入list0301 < NUL 程序会怎么样呢？！试试看，因为我们写一个程序必须要考虑到任何情况，程序写得壮壮的才好！

郁闷直接就这样了！难道C++不允许除数为0吗？！肯定是的，不然怎么程序就这样了呢！那怎么办呀！只有修改程序了，如何修改呢，既然C++不让除数为0，那么我就检查下如果为0，就不让程序进行除法运算！怎么去检查呢，用if吧，做一个条件结构控制，那么现在就改写程序！

嗯，现在好啦！为了检测程序，我另外输入几个数据运行着玩玩：

好奇怪！这是怎么回事，2+5+4=11 11/3=3 ！不对吧!怎么小数哪里去了！难道C++把小数跟扔了，通过搜寻相关资料后知道了，其他一些语言对于整数除法和浮点数除法使用不通的操作符，而C++使用的是相同的操作符，然后根据上下文决定使用哪种除法。如果2个数都是整数，则结果也是整数。比如5/3和 4/3是等价的，都等于1.

测试整数的奇偶性

这个程序就差一步啦！既然要判断奇偶性呢！就用取余吧！因为要是是偶数%2=0，奇数%2=1啊！对！就这样办了！

这个程序算是成功了！再思考了下，这里我用的!=，能不能用==呢!当然能了，只是下面的打印信息得换个位置了！写这个程序刚开始时候的时候，我还犯错了，我改写的时候把==写成=,刚开始还不知道怎么回事呢！我以后一定要注意这个问题。

修改打印平均值程序

突然想到了1个问题，就是刚才打印平均值的那个程序，当count为0 的时候，程序就退出了，没有任何提示的退出，我觉得这样实在太不好了！应该给人1个提示啊，那么现在再改改那个程序：

嗯！现在差不多啦！够健壮啦！刚才又差点犯1个错误，我差点习惯性的把count == 0 写成count = 0 啦！结果编译器没有报错，如图：

晕！应该会报错的呀！通过搜寻资料发现，原因是我没有开启-Wall编译器参数，但是我找遍了IDE每个地方都没有发现如何去添加编译器参数！要是谁知道请告诉我！谢谢呢！

本文链接

我也要学C++_第一章：CodeLite的安装配置和第一个C++程序的阅读

2011-07-15T01:14:00Z

CodeLite的安装配置

CodeLite是一个强大的开源,跨平台的C/C++整合开发环境. 支持包括Windows、Linux 和Mac 系统下运行。换CodeLite也是一时心血来潮，呵呵！暂时换个IDE，就像家里面换了1扇窗户，有了一种新鲜感。这样继续学习编程会多增添1点乐趣，有更多的乐趣在前进的道路上才不会那么的孤单！

CodeLite其实和VC6.0很相似的。功能，甚至快捷键都一样，所以适应会很快的。只是CodeLite我用的g++编译器，以前VC6.0的是cl编译器。调试器嘛！CodeLite我用的是GDB，VC6.0的调试器我就不知道是什么了，没发现有单独的调试器程序存在，应该是做在一起了吧，就像八宝粥，米啊！坚果啊！都混在一起了。

CodeLite的下载：http://www.codelite.org/ 到这个地址去下载就好了，最好选择整合版的，就是CodeLite和MinGW捆绑在一起的那个文件，这样你就不必单独去下载了啊。那个整合版的好像是24M。

CodeLite的安装与配置：安装就很简单了，直接下一步下一步就可以了。只是在安装结束后记得设置下debugger:Settings > Debugger Settings > Loaded Debugger > Debugger Path。将Path设置为：X:\MinGW\gdb\bin\gdb.exe 这样设置好了后，就可以开始使用啦！

CodeLite编写调试运行helloworld:Workspace > New project > 然后选择代码类型与工程名和保存路径以及编译器选择（如图）：

然后OK后，就出现了代码编辑主窗口啦！

呵呵！还不错吧！样子挺酷的！不过我们既然要调试就多写点代码吧！

很酷吧！其实和VC6.0一样了的！非常容易上手啦！你看那个i的值，0x开头的，呵呵！安装配置和简单调试就到这里了，不过有个很严重的问题也,这个是C++程序吗，怎么和C一样的啊！是啊！哦，原来是C++兼容C，所以你写标准C，编译运行调试都是没有问题的，那么什么时候开始真正C++的征途啊，马上就开始啦！

第一个C++的阅读

啊！直接就读C++了啊！一直就读，是不是太快了点呢，不会的，因为我之前学过C了啊，C++是C语言发展起来的，虽然它们之间没有什么关系，但是C++是兼容C的，所以直接读C++程序应该没什么问题了！下面开始读了：

//试着阅读此段程序，尽量读懂程序的功能

#include <iostream>
#include <istream>
#include <limits>
#include <ostream>

int main()
{
int min(std::numeric_limits<int>::max());
int max(std::numeric_limits<int>::min());

bool any(false);

int x;

while(std::cin >> x)
{
any = true;

if(x < min)
{
min = x;
}

if(x > max)
{
max = x;
}

}

if(any)
{
std::cout << "min =" << min << "\nmax =" << max << '\n';
}
return 0;
}

这个程序的功能是什么呢？！稍微读下了后，因为有C基础嘛！不是很困难的就得到了，这段程序就是从标准输入设备读取一系列的整数，然后记录其最大和最小值，在最后打印出它们来。

代码分析：

第1行：1个的双斜杠开始了一行的注释。注意,两斜杠之间不能插入空格，因为C++编译器看到符号时，总会试图构建有可能最长的符号。注释也可以用/**/的形式注释。两种风格的注释可以相互嵌套，但是注意，同种风格的注释不能嵌套使用。如果我们把上段程序换成/**/风格的注释，然后编译，结果会和//风格的一样吗？！答案是不一定的哦！因为某些二进制格式中包含时间戳，所以某些时候两次编译生成的结果不一样。

第3-6行：复制粘帖头文件。第3行是告诉编译器，cin作为标准输入流，cout作为标准输出流。第4行是把输入操作符 >> 的定义告诉编译器。第5行是引入std::numeric_limits这个名字。第6行是引入输入操作符 << . 因为如此繁琐啊！因为编译器很笨，它不像人，人可以通过上下文来推断一些词语的意思，但是编译器就不会了，所以我们必须用#include告诉编译器一些符号或者标识符的含义以及它在一段程序中扮演的什么角色，是什么地位。比如我故意把limits写成stimil后再编译，首先，编译器无法找到stimil这个文件，编译器就会报告1条消息，然后编译器试着去编译，因为此刻编译器不知道std::numeric_limits是什么呢！因此就会报错了，而且报错可能不只一条错误，因为有的编译器会将消息级联，也就是每使用1次std::numeric_limits就会产生错误，而真正的错误就被这些级联带来的错误给包围啦！如何突出重围找到真正的错误呢，就是应当首先关注编译器爆出的前几条错误，修正后一般都能解决所有的错误。在修正错误的时候，笨笨的编译器一般是不会说使用std::numeric_limits之前需要复制粘帖<limits>头文件这样的消息。那怎么办呢，最好此刻查询报错行关键字为线索的帮助文档。级联式错误报告如图：

哈哈！G++首先就说没有找到stimits这个文件，所以我首先就想到了是不是stimits这个名字写错了，因为正确的安装了开发包啊~

第8行：大多数时候每个C++程序都有一个int main(), main之前的返回值必须是int，我之前程序写过void，这点是不规范的，之前我在C笔记中也提到过。为什么是大多数时候呢，因为main()用户态入口函数是可以自定义的。关于自定义入口函数，以后我会了我再写笔记了。

第10-13行：为了避免直接和地址打交到，所以使用了变量。声明变量首先是变量的数据类型，然后是变量的名字。变量的名字后可以加上初始值，初始值用括号包起来。这里的std::numeric_limits是属于C++标准库，可以用来查询内置算术类型的属性。这样是不是很方便啊，以前写C语言还要自己去算下，这里直接使用标准库啦！我这里是查询的int，如果我们查询另外的，比如bool的min()，结果是什么呢，呵呵！如果查询bool的二进制位：std::numeric_limits<bool>::digits呢？！这些都不难了，要知道到底有哪些属性可以去查询，那么就看帮助文档就好了呢！

第14-23行：其中std::cin是表示从标准输入读取一个整数，并把这个整数存储在X变量的地址里。只要成功输入整数，条件就为真了，如果不是成功输入整数或者不是输入的整数，就为假了，循环就终止了！17行和19行的if没有写else分支，其实最好是写上，但是这里好像也没有写的必要，所以自己看着办了呢！23行的条件只有1个名字any，呵呵，因为它是bool类型，所以这里才可以直接用啊。要是这里不是bool类型的，你写成了if(x)会是什么结果啊？！C++把任何数值类型都可以做为条件，非零为真，零为假，这样的话，也就是程序背后做了一件这样的事，它把数值和0做了是否等于的测试。

第24行：>> 这个符号是输出操作符，可以用一个地址加其解释方式的值（也就是变量的值），或者解释方式为字符串的值，或者解释方式为字符，或者表达式的值。标准库把输出操作符放在了<ostream>头文件中，所以我们要复制粘帖这个头文件，这样编译器才能知道std::out这个名字。单个字符的时候注意要用单引号把它包起来，如果我们就要输出单引号呢，我们就用反斜杠转义它。如果是一个字符串的话就用双引号把它包起来，如果字符串中包含双引号同样用反斜线转义它。

此章节完了！我已经读懂了一个C++程序啦！然后再慢慢细节它，加油！

本文链接

汇编语言程序设计学习笔记（第一遍学习）-第4节：汇编就像HTML一样简单

2011-07-13T03:51:00Z

最近好多天没有更新笔记了，主要是最近几个月在写操作系统，比较忙点了，大约要写3个月左右呢，因为我学习的安排也会顺着兴趣随时做一些小的改动，因为兴趣是最好的老师嘛！今天在写操作系统之余再更新汇编的学习笔记。其实写操作系统也是对汇编，C语言，数据结构与算法的综合学习，很有趣味又能回顾知识点，还能熟悉操作系统原理，真是太好了！现在的笔记我会多写操作的描述，动手去练习然后发现问题比只是看书效率真的高很多哦！

DEBUG的“R”命令

当我们在CMD中键入 debug后，会进入debug系统，我们来看看debug中的一个命令'r'.当我们键入r后，会出现下面的画面：

是不是又发晕了，哈哈！要是又发晕，肯定是之前几节笔记没有仔细看呀！其实看起来蛮复杂，其实就只有14个寄存器！嗯？！不对呀！仔细一数没有14个啊！只有13个的啊，你说对了，比较明显的就13个，不过后面那排NV UP EI PL NZ NA PO NC是什么呀！其他它们是第14个寄存器中的8位！其实这14个寄存器都是16位的，那为什么这里只显示出其中的8位呀？！因为这个寄存器我们只用到了其中的9位，而且其中还有一位是单步调试中断使用，所以这里就只有8位了哦。每个寄存器都是16位的，大家能看出来吗？像图中的DS是1415，这个是16位知道的吗，要是不知道就去看我写的C语言学习笔记里面有写哦！一下子来了这么多的寄存器，我怎么知道里面谁是干什么用的呀！或者里面谁和谁又有什么关系啊？！其实寄存器就像这个社会中的不同的人，每个人有不通的工作方向和技术方向，所以每个寄存器也有它们各自的职能，社会中有些人是情侣，他们之间的关系比较亲密，其实寄存器中也有这样的关系的呢！具体怎么个关系和各自的特点，慢慢的说了哦！

其实大家发现1个问题没有，我们去网上下载操作系统的时候，一般不是32位的就是64的位，怎么这里的寄存器是16位的呢！我一直也为这个问题苦恼了小会.其实我们这里看到的寄存器是操作系统虚拟出来的，其实我们真正的电脑不是这样的结构的，哦！原来是这样，我就说呢，怎么有本书叫WINDOWS32位汇编语言程序设计。所以我们现在弄的这个是8086，16位汇编，32位以后再学了呢！最早的电脑是4位的，后来又是8位的，再后来出现了16位，由于在16位机器去上有好多特好的程序，随着硬件的发展，如果要兼容16位机的程序就必须制造16倍数的机器，所以后来就32位，64位了。但是在早起，硬件的成本很昂贵，为了达到高性价比的特点，就只用了20位地址线，这样的话，内存的寻找能力就是1M。但是我们的电脑并不处理20位数据呀！而且早在8位机的时候，一次还只能处理8位的数据，我先来看看，16位机器是如何处理8位数据的，我们看到寄存器是16位的，比如AX,BX,CX,DX如果把它们的1个16位的一分为二不就可以了吗，其实真实的情况就是这么处理的，AX分成AL,AH，其他同理。我们来实践实践加深理解。

T命令是单步执行的意思哦！大家看了吧！一起都在我们的掌握之中，不过有个地方很奇怪呀！IP怎么也在变，我们写的代码没有更改IP的值呀！其实通过细心的观察就知道了.比如1415:0100 后面的是IP的值，那么前面的1415是什么呢，仔细一看，1415和DS,ES,SS,CS的值一样，那么到底是其中的哪个的呢！其实是CS的。呵呵！为什么这样的，虽然，DS,ES,SS,CS的值都是1415，但是IP只喜欢CS，呵呵！所以它们是一对的。这样的话CS:IP就指向当前运行的代码。

我们再来看看刚才哪个问题，16位电脑中如何去用20位的地址线的。我们来看看刚才CS:IP的值：1415:0100。如果要16位变20位，只要左移4位不就可以了吗，关于位移如果不清楚的就去看我学C时候的笔记吧！所以为了解决这个问题就引入了段的概念。冒号前面的就叫做段地址，冒号后面的就叫做段内偏移地址。左移4位就是X16，所以真实的地址就是段地址X16+段内偏移地址。很简单吧！只是有点繁琐，但是没办法呀！为了兼容，只有这么办啦!所以电脑必须要提高段寄存器呀！所以DS ES SS CS就是4个段寄存器，我们现在知道了CS，代码段，那么其他是什么段呢，以前我学C时候的笔记不是分析了1个程序还有其他段的吗，那么其他3个具体表示什么呢，等以后的笔记再说了，这样一来是不是觉得汇编也什么难的呀！说到段，还要注意1个问题，就是不能对段进行直接赋值，如果我们写MOV DS，4444 会出错，为什么会这样呢?!其实这个没有为什么，造CPU的人就是这么造的，记住就好了啦！你可以用1个通用寄存器进行间接赋值就好了。不过有个奇怪的地方，我们如果用这种方法去修改CS的值为什么会跳出1个对话框，然后退出程序呢！那么怎么样才能修改CS的值呢？！这确实1个问题，这个问题下次笔记再说了。

我们再来看1个有趣又疑惑的问题。我们知道D命令是显示一段内存地址的值，那么我们来用D命令看1段内存，就看,03A3:006E吧！

我们再来看1段地址的值，我们就看03a0:009e

发现问题了没有，！怎么一模一样的，我们仔细一敲，也很正常啊！03A9E=03A30+006E ，03A9E=03A00+009E　。是吧！因为这个段是认为规定的，同样1个地址，你可以用很多种方式去寻址呢！

这节就到这里了，仔细算算，今天学到了不少东西呢，一起征服汇编吧！通过以前学习C语言，我觉得对汇编的理解也有好大的帮助的呢！你说是吗？！因为对于16进制我们早就熟悉了，对于内存，我们也好熟悉好熟悉了呢！发现没有！汇编和HTML很像，不知道你们是不是这样觉得的！

本文链接

我也要学C语言-第二十三章：微软未公开的堆内存（365天编程极限学习-第2天下午）

2011-07-05T02:09:00Z

int main(int argc, char *argv[], char *envp[])
{
int a = 1;
int b = 2;

return 0;
}

在这个代码中，变量a和b还有3个参数都在栈中，那么在栈里面分配的空间有什么特点的呢？！它们在编译器编译期限就为它们预留了空间。那么还有一个堆空间，它和栈空间有什么区别呢？！其实堆空间是在程序运行过程中，你需要什么就找它要什么。打个比方，就好像你去逛超市，你去之前你想买什么，你在脑子里面都已经想好了，到了超市你直接把你需要东西都买啦！这时候你买的这些东西一般都在栈中。但是你在超市里或者看到你当时还没有想买的又很想吃的东西呢，你肯定就再买啦！但是这些东西都是你出门前没有想到的东西，这时候你就需要另外规划钱了，你就再多计划点钱了，但是你身没带那么多钱怎么呀！你就去借点，在计算机中就是找操作系统去借啦！然后去买啦！这时候，这些东西一般就在堆中。而且在计算机里，你就需要向操作系统说，我还要点东西，呵呵！但是找操作系统再要内存，不一定要得到啊，有时候万一没有了呢，所以要内存的时候就需要做1个检查。因为是找操作系统借的，所以当用完了后还需要还给操作系统！如果不还就不行啊，因为你不还，大家也都不还，这样内存就耗尽了，就会出问题了。到底我们如何简单分辨到底在堆中还是栈中呢？！只要我们把握好申请内存的时机，计划内的就在栈，计划外的就在堆。另外要注意一个问题，堆栈是指的栈，和堆没关系。这就好比韩信好佩刀剑，其实他就是佩的剑。

C语言库中操作堆的2个函数malloc和free　

malloc这个函数就是找操作系统申请内存，这个函数是这样定义的：

void *malloc(size_t size); Required Header[<stdlib.h> and <malloc.h>]　

首先，这个函数是个C标准的库函数，当你使用malloc的时候，你不需要关系找操作系统申请内存的具体流程。否则你要用一个当地平台的API去申请内存。malloc.h相当于1个中介所呢！

如何使用malloc

　　首先你要包含库，stdlib.h或者malloc.h. 你在调用此函数的时候，你需要提供size_t类型的size. size_t其实就是int.然后返回值是一个void *. void *是一个指针，设计malloc的人无法知道你是把这段内存干嘛用呢？！所以只能返回void *啦！所以你用的时候就要进行一次强制转换，转换成你所设计的使用。

malloc是借，free是还

嘿嘿！你向操作系统借了东西，是要还的啊！操作系统就相当于上帝，你欠上帝的始终都要还的，呵呵！

free的定义：void free(void *memblock);

当你还内存的时候，你就需要告诉它你要还什么，这个*memblock参数就是申请到的内存首地址。

程序实例：

int main()
{
int *pInt = NULL;//必须先初始化为NULL,
pInt = (int *)malloc(sizeof(int));//一定要转换哦！不然报错！强制为你所设计的

if(NULL == pInt)//必须做检查，检查申请成功了没，如果申请成功返回首地址，不成功就返回NULL也就是0。
{
return -1;//这里设置成你的合适的处理方式，不一定是退出。
}

if(pInt)//在释放之前必须做检查。
{
free(pInt);
pInt = NULL;//释放完了以后必须再次设置为NULL，杜绝野指针。
}

return 0;
}

我们来看看，我们的堆空间到底是什么样子的。

这里看到了1个以前没有看到过的地址段，0x003706e0。这个应该就是操作系统分配的堆空间的地址，这个地址我们从内存中可以看到1些特点.在调试版下，它有一些结构去辅助程序的调试。我们看到这里地址值被初始化为CD，在栈空间是初始化的CC。哦！原来是这样，那么我们以后只要看到CD了，就知道是调试版的啦！然后再单步一下，值就赋为7了。

内存泄漏

（上面截图有个书写错误，就是sizeof(char)应该是sizeof(char[])）这个程序正确的吗？我们仔细一瞧，不对呀！0x0042028是只读数据区的地址呀!这样的话，就是说，Ipstr的值被覆盖了，这样的话，原来的内存就无法释放了，这样的话就叫内存泄漏了。这样的话free的时候就要出错啦！为什么会出错啊，就是因为释放了1个常量。

以后千万不要犯这样的错误啊！那么要怎么写才对呢？！我们这里就要用到1个函数啦！：strcpy(lpstr, "Hello world");

但是还是有个问题，就是这里只是1个记录，要是我要把1千万个学生放如内存，如何去释放呢，我相信继续学习后某天一定会知道的了。

刚才程序报错，为什么它知道我们释放的不是堆内存呢？！进一步调试下，

因为堆内存都微软没有公开的资料，所以很多堆的特性都是通过逆向工程，和通过前辈高人的研究成果。堆很有特点：

1：首先调试版下，初始化为全CD

2：前后4个FD，防止溢出，如果FD被破坏，调试版的时候会给警告

3：堆是一个双项链表结构，在当前堆指针减16的地方就到了堆的数据长度，这就是为什么后面FD位置的确定

4：这个是和操作系统版本相关的，以上适合于WINDOWS XP

5：如果FD被破坏了，你可以手工修复，程序一样可以正确运行

本文链接