Technorati 标签: rrr

teat6

test4

Test33333

Test2

Just a test!

msn spaces太慢,经常性打不开,虽然功能强大,但每次上来都感觉不容易

用了几天的百度空间之后,感觉百度很快,很爽,所以……

在此也隆重向大家推荐百度空间！！虽然有时候百度也挺龌鹾的

我在百度空间的地址：

欢迎访问和留言！

3只羊3只狐狸要过河,只有一条船,船上一次最多只能载2个动物,狐狸和羊自己都会开船,要求任何时候任何一个地方的狐狸的数目不能大于羊的数目,否则羊会被吃掉,请描述过河方法

 

有谁会不?呵呵

case:     break语句用来在执行完一个case分支后，使程序跳出switch语句，即终止switch语句的执行。因为case子句只是起到一个标号的作用，用来查找匹配的入口并从此处开始执行，对后面的case子句不再进行匹配，而是直接执行其后的语句序列，因此该在每个case分支后，要用break来终止后面的case分支语句的执行。在一些特殊情况下，多个不同的case值要执行一组相同的操，这时可以不用break。

 

memcpy,strncpy:     strncpy是把Num个字符从src复制到dest，但是如果遇到src字符结尾，那么复制提前结束，后面没有复制完的字符，不予以处理，当然dest，src地址不能重叠；

memcpy也是把Num个字符从src复制到dest，但是它是内存复制，不管是不是NULL，照样通吃。

 

memset：   memset用来对一段内存空间全部设置为某个字符，一般用在对定义的字符串进行初始化为‘ ’或‘\0’；例:char a[100];memset(a, '\0', sizeof(a));
memset是对每个字节赋值，比如这样,memset(a,1,sizeof(a));
则a中的每个元素都被赋值成为2进制数为，00000001000000010000000100000001，的数
转换成10进制就是16843009

 

#include "iostream.h"
int p(int x)
{
static int y=1;
y=y+1;
return (x+y);}
int main()
{
cout<<p(1)<<endl;
cout<<p(2)<<endl;}
静态变量是这样的:静态变量的内存是整个程序开始就分配了内存,整个程序结束后内存才消失!动态变量的就是用的时候才动态分配,用完之后就消失了!静态变量给了变量初始的值,然后如果在程序中该值有变化的,那当前的值就是变化后的值,这个是它的原理
你的初始值是1,第一次结果有变化,是2,所以静态变量当前值是2,所以输出的是3,下次用2,所以结果是5

      经过生活的总结与发现和观察，发现一个具有普遍性的规律，由于现阶段尚未得到完整的数学证明，所以只能称之为猜想，我们称之为朱氏第一猜想，以后再有猜想就顺延叫第二、第三……

      猜想的正文是：

      一个原来一直没有谈过恋爱的女生，大学毕业走出学校后的一年内，必定会谈恋爱。    

      可能还不很严谨，希望大家补充。

      同时希望大家能给出证明：）

      这个猜想对大家尤其是男生具有非常实用普遍的指导意义，相信大家也能明白，呵呵

     

sizeof

                                      

解析C语言中的sizeof

一、sizeof的概念　
　　sizeof是C语言的一种单目操作符，如C语言的其他操作符++、--等。它并不是函数。sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。操作数的存储大小由操作数的类型决定。　

二、sizeof的使用方法　
　　1、用于数据类型　

　　sizeof使用形式：sizeof（type）　

　　数据类型必须用括号括住。如sizeof（int）。　

　　2、用于变量　

　　sizeof使用形式：sizeof（var_name）或sizeof　var_name　

　　变量名可以不用括号括住。如sizeof　(var_name)，sizeof　var_name等都是正确形式。带括号的用法更普遍，大多数程序员采用这种形式。　

　　注意：sizeof操作符不能用于函数类型，不完全类型或位字段。不完全类型指具有未知存储大小的数据类型，如未知存储大小的数组类型、未知内容的结构或联合类型、void类型等。　

　　如sizeof(max)若此时变量max定义为int　max(),sizeof(char_v)　若此时char_v定义为char　char_v　[MAX]且MAX未知，sizeof(void)都不是正确形式。　

三、sizeof的结果　
　　sizeof操作符的结果类型是size_t，它在头文件

中typedef为unsigned　int类型。该类型保证能容纳实现所建立的最大对象的字节大小。　

　　1、若操作数具有类型char、unsigned　char或signed　char，其结果等于1。　

　　ANSI　C正式规定字符类型为1字节。　

　　2、int、unsigned　int　、short　int、unsigned　short　、long　int　、unsigned　long　、float、double、long　double类型的sizeof　在ANSI　C中没有具体规定，大小依赖于实现，一般可能分别为2、2、2、2、4、4、4、8、10。　

　　3、当操作数是指针时，sizeof依赖于编译器。例如Microsoft　C/C++7.0中，near类指针字节数为2，far、huge类指针字节数为4。一般Unix的指针字节数为4。　

　　4、当操作数具有数组类型时，其结果是数组的总字节数。　

　　5、联合类型操作数的sizeof是其最大字节成员的字节数。结构类型操作数的sizeof是这种类型对象的总字节数，包括任何垫补在内。　

　　让我们看如下结构：　

　　struct　{char　b;　double　x;}　a;　

　　在某些机器上sizeof（a）=12，而一般sizeof（char）+　sizeof（double）=9。　

　　这是因为编译器在考虑对齐问题时，在结构中插入空位以控制各成员对象的地址对齐。如double类型的结构成员x要放在被4整除的地址。　

　　6、如果操作数是函数中的数组形参或函数类型的形参，sizeof给出其指针的大小。　

四、sizeof与其他操作符的关系　
　　sizeof的优先级为2级，比/、%等3级运算符优先级高。它可以与其他操作符一起组成表达式。如i*sizeof（int）；其中i为int类型变量。　

五、sizeof的主要用途　
　　1、sizeof操作符的一个主要用途是与存储分配和I/O系统那样的例程进行通信。例如：　

　　void　*malloc（size_t　size）,　

　　size_t　fread(void　*　ptr,size_t　size,size_t　nmemb,FILE　*　stream)。　

　　2、sizeof的另一个的主要用途是计算数组中元素的个数。例如：　

　　void　*　memset（void　*　s,int　c,sizeof(s)）。　

六、建议　
　　由于操作数的字节数在实现时可能出现变化，建议在涉及到操作数字节大小时用sizeof来代替常量计算。

本文主要包括二个部分，第一部分重点介绍在VC中，怎么样采用sizeof来求结构的大小，以及容易出现的问题，并给出解决问题的方法，第二部分总结出VC中sizeof的主要用法。

1、 sizeof应用在结构上的情况

请看下面的结构：

struct MyStruct

{

double dda1;

char dda;

int type

};

对结构MyStruct采用sizeof会出现什么结果呢？sizeof(MyStruct)为多少呢？也许你会这样求：

sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13

但是当在VC中测试上面结构的大小时，你会发现sizeof(MyStruct)为16。你知道为什么在VC中会得出这样一个结果吗？

其实，这是VC对变量存储的一个特殊处理。为了提高CPU的存储速度，VC对一些变量的起始地址做了“对齐”处理。在默认情况下，VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。下面列出常用类型的对齐方式(vc6.0,32位系统)。

类型
对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量）

Char
偏移量必须为sizeof(char)即1的倍数

int
偏移量必须为sizeof(int)即4的倍数

float
偏移量必须为sizeof(float)即4的倍数

double
偏移量必须为sizeof(double)即8的倍数

Short
偏移量必须为sizeof(short)即2的倍数

各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节VC会自动填充。同时VC为了确保结构的大小为结构的字节边界数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。

下面用前面的例子来说明VC到底怎么样来存放结构的。

struct MyStruct

{

double dda1;

char dda;

int type

}；

为上面的结构分配空间的时候，VC根据成员变量出现的顺序和对齐方式，先为第一个成员dda1分配空间，其起始地址跟结构的起始地址相同（刚好偏移量0刚好为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；接下来为第二个成员dda分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的地方满足对齐方式，该成员变量占用sizeof(char)=1个字节；接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为9，不是sizeof(int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构的起始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：8+1+3+4=16，刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。所以整个结构的大小为：sizeof(MyStruct)=8+1+3+4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。

下面再举个例子，交换一下上面的MyStruct的成员变量的位置，使它变成下面的情况：

struct MyStruct

{

char dda;

double dda1;

int type

}；

这个结构占用的空间为多大呢？在VC6.0环境下，可以得到sizeof(MyStruc)为24。结合上面提到的分配空间的一些原则，分析下VC怎么样为上面的结构分配空间的。（简单说明）

struct MyStruct

{

char dda;//偏移量为0，满足对齐方式，dda占用1个字节；

double dda1;//下一个可用的地址的偏移量为1，不是sizeof(double)=8

//的倍数，需要补足7个字节才能使偏移量变为8（满足对齐

//方式），因此VC自动填充7个字节，dda1存放在偏移量为8

//的地址上，它占用8个字节。

int type；//下一个可用的地址的偏移量为16，是sizeof(int)=4的倍

//数，满足int的对齐方式，所以不需要VC自动填充，type存

//放在偏移量为16的地址上，它占用4个字节。

}；//所有成员变量都分配了空间，空间总的大小为1+7+8+4=20，不是结构

//的节边界数（即结构中占用最大空间的类型所占用的字节数sizeof

//(double)=8）的倍数，所以需要填充4个字节，以满足结构的大小为

//sizeof(double)=8的倍数。

所以该结构总的大小为：sizeof(MyStruc)为1+7+8+4+4=24。其中总的有7+4=11个字节是VC自动填充的，没有放任何有意义的东西。

VC对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。

VC中提供了#pragma pack(n)来设定变量以n字节对齐方式。n字节对齐就是说变量存放的起始地址的偏移量有两种情况：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；

否则必须为n的倍数。下面举例说明其用法。

#pragma pack(push) //保存对齐状态

#pragma pack(4)//设定为4字节对齐

struct test

{

char m1;

double m4;

int m3;

};

#pragma pack(pop)//恢复对齐状态

以上结构的大小为16，下面分析其存储情况，首先为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1占用1个字节。接着开始为m4分配空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。接着为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。这时已经为所有成员变量分配了空间，共分配了16个字节，满足为n的倍数。如果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以得到结构的大小为24。（请读者自己分析）

2、 sizeof用法总结

在VC中，sizeof有着许多的用法，而且很容易引起一些错误。下面根据sizeof后面的参数对sizeof的用法做个总结。

A． 参数为数据类型或者为一般变量。例如sizeof(int),sizeof(long)等等。这种情况要注意的是不同系统系统或者不同编译器得到的结果可能是不同的。例如int类型在16位系统中占2个字节，在32位系统中占4个字节。

B． 参数为数组或指针。下面举例说明.

int a[50]; //sizeof(a)=4*50=200; 求数组所占的空间大小

int *a=new int[50];// sizeof(a)=4; a为一个指针，sizeof(a)是求指针

//的大小,在32位系统中，当然是占4个字节。

C． 参数为结构或类。Sizeof应用在类和结构的处理情况是相同的。但有两点需要注意，第一、结构或者类中的静态成员不对结构或者类的大小产生影响，因为静态变量的存储位置与结构或者类的实例地址无关。

第二、没有成员变量的结构或类的大小为1，因为必须保证结构或类的每一

个实例在内存中都有唯一的地址。

下面举例说明，

Class Test{int a;static double c};//sizeof(Test)=4.

Test *s;//sizeof(s)=4,s为一个指针。

Class test1{ };//sizeof(test1)=1;

D． 参数为其他。下面举例说明。

int func(char s[5]);

{

cout<
//数的参数在传递的时候系统处理为一个指针，所

//以sizeof(s)实际上为求指针的大小。

return 1;

}

sizeof(func(“1234”))=4//因为func的返回类型为int，所以相当于

//求sizeof(int).

以上为sizeof的基本用法，在实际的使用中要注意分析VC的分配变量的分配策略，这样的话可以避免一些错误。

9、struct的sizeof问题

    因为对齐问题使结构体的sizeof变得比较复杂，看下面的例子：(默认对齐方式下)

struct s1
{
  char a;
  double b;
  int c;
  char d;
};

struct s2
{
  char a;
  char b;
  int c;
  double d;
};

cout<<sizeof(s1)<<endl; // 24
cout<<sizeof(s2)<<endl; // 16

    同样是两个char类型，一个int类型，一个double类型，但是因为对界问题，导致他们的大小不同。计算结构体大小可以采用元素摆放法，我举例子说明一下：首先，CPU判断结构体的对界，根据上一节的结论，s1和s2的对界都取最大的元素类型，也就是double类型的对界8。然后开始摆放每个元素。
    对于s1，首先把a放到8的对界，假定是0，此时下一个空闲的地址是1，但是下一个元素d是double类型，要放到8的对界上，离1最接近的地址是8了，所以d被放在了8，此时下一个空闲地址变成了16，下一个元素c的对界是4，16可以满足，所以c放在了16，此时下一个空闲地址变成了20，下一个元素d需要对界1，也正好落在对界上，所以d放在了20，结构体在地址21处结束。由于s1的大小需要是8的倍数，所以21-23的空间被保留，s1的大小变成了24。
    对于s2，首先把a放到8的对界，假定是0，此时下一个空闲地址是1，下一个元素的对界也是1，所以b摆放在1，下一个空闲地址变成了2；下一个元素c的对界是4，所以取离2最近的地址4摆放c，下一个空闲地址变成了8，下一个元素d的对界是8，所以d摆放在8，所有元素摆放完毕，结构体在15处结束，占用总空间为16，正好是8的倍数。

    这里有个陷阱，对于结构体中的结构体成员，不要认为它的对齐方式就是他的大小，看下面的例子：

struct s1
{
  char a[8];
};

struct s2
{
  double d;
};

struct s3
{
  s1 s;
  char a;
};

struct s4
{
  s2 s;
  char a;
};

cout<<sizeof(s1)<<endl; // 8
cout<<sizeof(s2)<<endl; // 8
cout<<sizeof(s3)<<endl; // 9
cout<<sizeof(s4)<<endl; // 16;

    s1和s2大小虽然都是8，但是s1的对齐方式是1，s2是8（double），所以在s3和s4中才有这样的差异。

    所以，在自己定义结构体的时候，如果空间紧张的话，最好考虑对齐因素来排列结构体里的元素。

10、不要让double干扰你的位域

    在结构体和类中，可以使用位域来规定某个成员所能占用的空间，所以使用位域能在一定程度上节省结构体占用的空间。不过考虑下面的代码：

struct s1
{
  int i: 8;
  int j: 4;
  double b;
  int a:3;
};

struct s2
{
  int i;
  int j;
  double b;
  int a;
};

struct s3
{
  int i;
  int j;
  int a;
  double b;
};

struct s4
{
  int i: 8;
  int j: 4;
  int a:3;
  double b;
};

cout<<sizeof(s1)<<endl;  // 24
cout<<sizeof(s2)<<endl;  // 24
cout<<sizeof(s3)<<endl;  // 24
cout<<sizeof(s4)<<endl;  // 16

    可以看到，有double存在会干涉到位域（sizeof的算法参考上一节），所以使用位域的的时候，最好把float类型和double类型放在程序的开始或者最后。

1.
void *p=malloc(100);
sizeof(p)=4;
---------------------指针的字节数，而不是指针指向的内容容量
2. 
void Func(char str[100])
{sizeof(str)=4;}
--------------------数组作为函数的参数进行传递时，该数组自动退化为同类型的指针
3.
char str[100];
sizeof(str)=100;
--------------------不是函数的参数时
4.
char str[]="hello";
char *p=str;
int n=10;
sizeof(str)=6;sizeof(p)=4;sizeof(n)=2;
--------------------参考上面的

注：我觉得sizeof(n)应该是4，如果在32位操作系统下
5.
#define A 3
#define B 4
#define C A+B
#define s(x) x*x
s(c)=A+B*A+B=3+4*3+4=19;
-------------------宏展开只是简单的字符串替换

 

网络方面的一些：
iso 7层模型
tcp/ip 5层
tcp/udp 区别
交换机工作在 数据链路层
路由器工作在 网络层
hub工作在 物理层

    假设我们从公安部或国家统计局,哦或是联合国人类研究组织:)的数据库中找到一个表,表名为mm_info,此表包含mm_name,age,area,heigh,weight,wedlok,beautiful(漂亮指数,以1-1000衡量)等属性,我们用select top 200 * from mm_info where age between 20 and 24 AND height between 158 and 174 AND weight between 45kg and 55kg AND area = 'hunan' AND wedlock = null order by beautiful desc      然后随便选一个就可以了

Table_name表格

name	Sales	Date
Los Angeles	$1500	Jan-05-1999
San Diego	$250	Jan-07-1999
Los Angeles	$300	Jan-08-1999
Boston	$700	Jan-08-1999

 

SELECT

 

1,  SELECT name FROM table_name

2,  SELECT DISTINCT name FROM table_name     (name排除重复值)

3,  SELECT name FROM table_name WHERE Sales > 1000

4,  SELECT name FROM table_name WHERE Sales > 1000
  OR (Sales < 500 AND Sales > 275)

5,  SELECT * FROM table_name WHERE name IN ('Los Angeles', 'San Diego')

6,  SELECT * FROM table_name WHERE Sales between 300 and 1200

7,  SELECT * FROM table_name WHERE name LIKE '%AN%'  ('_'表示一个任意字符, '%'表示任意个任意字符)

8,  SELECT name, Sales, Date FROM table_name ORDER BY Sales DESC
SELECT name, Sales, Date FROM table_name ORDER BY 2 DESC
以上两句效果是一样的,2代表栏目sales,1代表name,3代表data,ASC为从小到大排列,DESC为从大到小排列

9,  SELECT SUM(Sales) FROM table_name
SUM为求和函数,其他函数还有AVG(平均)、COUNT(记数)、MAX(最大)、MIN(最小)等等

10, SELECT COUNT(name) FROM table_name WHERE name is not NULL

    SELECT COUNT(DISTINCT name) FROM table_name WHERE name is not NULL
 (第一句是计算非空name的个数,结果是4;第二句是计算非空且name分别不同的name的个数，结果是3)

11, SELECT name, SUM(Sales) FROM table_name GROUP BY name
(计算每个店的总销售额，结果为Los Angeles,$1800;San Diego,$250;Boston,$700;此时要用GROUP BY) 

12, SELECT name, SUM(sales) FROM table_name GROUP BY name HAVING SUM(sales) > 1500    (HAVING为函数条件)

 

先搞这么多吧,休息一下

#define M 300
void Inorder(tree T)
tree queue[M];
tree *p;
int front,near;
if(T!=null)
{
front=near=1;

queue[near++]=T;

while(p!=null&&near>front)

{

p=queue[front++]
visit p;

if(p->lchild!=null)

queue[near++]=p->lchild;

if(p->rchild!=null)

queue[near++]=p->rchild;

}

}

好象有点问题，有点忘了，以后再更正

#define M 300
void Postorder(tree T)
tree stack1[M];
int stack2[M];
tree *p;
int top,flag;
if(T!=null)

{top=1;
p=T;
flag=0;

 

do{

 

while(p!=null){
stack1[top]=p;
stack2[top++]=flag;
p=p->lchild;}

 

p=stack1[top];
flag=stack2[top--];

 

if(flag==0){
flag=1;
stack1[top]=p;
stack2[top++]=flag;
p=p->rchild;}

 

else{
visit p;
break;}

 

}while(p!=null||T!=null)

}

回忆一下，把二叉树的几个遍历写一下，近来有可能会用到

 

中序遍历

#define M 300

void Inorder(tree T)
tree stack[M];
tree *p;
int top;
if(T!=null)
{

top=1;
p=T;

do{

while(p!=null)

{
stack[top++]=p;        /*进栈*/
p=p->lchild;      

}

 

p=stack[top--];        /*出栈*/
visit p;
p=p->rchild;

}
while(p!=null||T!=null)

}

 

 

1、设置最多返回条数：
有时候符合查询的记录可能有很多条，但我们并不需要查看全部记录，只是想看前几条记录。
如：看前6条件记录
select top 6 * from tablename order by id desc                         *desc为递减，asc为递增
另一种可以用百分比返回记录数：
select top 20 percent * from tablename order by id desc
意思是返回全部记录的百分之二十的记录。

 

2、数据库中的指针操作指令：
objRS.movenext 将记录指针从当前的位置向下移一行
objRS.moveprevious 将记录指针从当前的位置向上移一行
objRS.movefirst 将记录指针移到数据表第一行
objRS.movelast 将记录指针移到数据表最后一行
objRS.recordcount 返回记录总数 ,但必须rs.open strSQL,objDB,3,3时才有效       *1,3时好象也有效？

1，插入记录

objDB.execute("insert into table(fields1,fields2，fields3,…)values('"&变量1&"','"&变量2&"','"&变量3&"',…)   ")

 

2，查询记录

objRS.open "select * from info order by id desc",objDB,1,3

 

3，删除记录

objDB.execute("delect * from tablename where 条件")

 

4，更新记录

objDB.execute("update tablename set fields1=数值1,fields2=数值2 where fields=条件")

asp几个初学的东西,整理一下：

 

以留言本的程序为例，一般的顺序是这样的：

1,首先是建立数据库的连接，好象开始都是创建服务器对象

   set db=Server.CreateObject("adodb.connection") 

   set rs=Server.CreateObject("adodb.recordset")

 

   打开数据库

   db.open "Provider = Microsoft.Jet.OLEDB.4.0;Data Source = " & Server.MapPath("db.mdb")

   上面那段字符串是固定对acess数据库的，db.mdb是数据库的相对路径，上面在当前目录

 

2，将表单内容提交数据库，就是一个SQL语句

   db.execute("insert into t_message (username,content) values(' "&username&" ', '" &message&" ' )  ")

    这个语句也够复杂的，前一个username,content是数据库中的属性名，后一个username,content是表单对应域的名字，表示将表单中的内容插入数据库中

 

3，将数据库的内容读出来显示

    用一个循环语句将数据项全部读出来（部分读出现在还不知道）

   while (not rs.eof)

   <%=rs("username")%>

   <%=rs("message")%>

    rs.movenext

    wend

   用for语句也可以，在C中特别爱用for语句，试一下：

   for 1 to rs.recordcount

   <%=rs("username")%>