欧美成a人片免费看久久,久久国产成人午夜AV影院,国产成人无码精品久久久免费

luis — Sun, 13 Feb 2011 17:32:00 GMT

(1)指针和引用的问题
java中没有指针，但是数组名，对象名都是其引用�Q?br>指针�q�有帔R��指针�Q�比如数�l�名
(2)new的区�?br>java中的new�q�回对象的应�?br>c++中的new�q�回其指针，
如果c++�?br>SparseMatrix s=SparseMatrix(4,4,6,arrays);
如果java�?br>SparseMatrix s=new SparseMatrix(4,4,6,arrays);

luis 2011-02-14 01:32 发表评论

luis — Sun, 13 Feb 2011 17:14:00 GMT

原文地址http://www.ksarea.com/articles/20070829_memory-partition-stack-heap-difference.html

一直对内存区域的划分，�E�序变量的内存分配问题模�p�不清。进行多方参考�ȝ��如下�?/p>

一、一个经�q�编译的C/C++的程序占用的内存分成以下几个部分�Q?br>1、栈区（stack�Q�：��q��译器自动分配和释�?nbsp;�Q�存攑և�数的参数倹{��局部变量的值等�Q�甚臛_��数的调用�q�程都是用栈来完成。其操作方式�c�M��于数据结构中的栈�?br>2、堆区（heap�Q?nbsp;�Q�一般由�E�序员手动申请以及释放，若程序员不释放，�E�序�l�束时可能由OS回收。注意它与数据结构中的堆是两回事�Q�分配方式类��g��链表�?br>3、全局区（静态区�Q�（static�Q�：全局变量和静态变量的存储是放在一块的�Q�初始化的全局变量和静态变量在一块区域，未初始化的全局变量和未初始化的静态变量在盔R��的另一块区域。程序结束后��q��l�释攄��间�?nbsp;
4、文字常量区�Q�常量字�W�串��是攑֜��q�里的�?nbsp;�E�序�l�束后由�pȝ��释放�I�间�?br>5、程序代码区�Q�存攑և��C��的二�q�制代码�?/p>

下面的例子可以完全展�C�Z��同的变量所占的内存区域�Q?br>
//main.cpp
int a = 0; 全局初始化区
char *p1; 全局未初始化�?br>main()
{
int b; //栈中
char s[] = “abc”; //栈中
char *p2; //栈中
char *p3 = “123456″; //123456\0在常量区�Q�p3在栈�?br>static int c =0�Q?//全局�Q�静态）初始化区
//以下分配得到�?0�?0字节的区域就在堆�?br>p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
strcpy(p1, “123456″); //123456\0攑֜�帔R��区，�~�译器可能会��它与p3所指向�?#8221;123456″优化成一个地斏V�?br>}

二、栈�Q�stack�Q�和堆（heap�Q�具体的区别�?br>1、在甌��方式�?br>栈（stack�Q? 现在很多人都�U�C��为堆栈，�q�个时候实际上�q�是指的栈。它��q��译器自动��理�Q�无需我们手工控制�?例如�Q�声明函��C��的一个局部变�?int b �pȝ��自动在栈中�ؓb开辟空��_��在调用一个函数时�Q�系�l�自动的�l�函数的形参变量在栈中开辟空间�?br>堆（heap�Q? 甌��和释攄��E�序员控�Ӟ��q�指明大��。容易��生memory leak�?br>在C中��用malloc函数�?br>如：p1 = (char *)malloc(10);
在C++中用new�q�算�W��?br>如：p2 = (char *)malloc(10);
但是注意p1本��n在全局区，而p2本��n是在栈中的，只是它们指向的空间是在堆中�?/p>

2、申请后�pȝ��的响应上
栈（stack�Q?只要栈的剩余�I�间大于所甌��I�间�Q�系�l�将为程序提供内存，否则��报异常提示栈溢出�?br>堆（heap�Q? 首先应该知道操作�pȝ��有一个记录空闲内存地址的链表，当系�l�收到程序的甌��Ӟ�� 会遍历该链表�Q�寻扄��一个空间大于所甌��I�间的堆�l�点�Q�然后将该结点从�I�闲�l�点链表中删除，�q�将该结点的�I�间分配�l�程序。另外，对于大多数系�l�，会在�q�块内存�I�间中的首地址处记录本�ơ分配的大小�Q�这��P��代码中的delete或free语句才能正确的释放本内存�I�间。另外，�׃��扑ֈ�的堆�l�点的大��不一定正好等于申��L��大小�Q�系�l�会自动的将多余的那部分重新攑օ��I�闲链表中�?/p>

3、申请大��的限制
栈（stack�Q?在Windows�?栈是向低地址扩展的数据结构，是一块连�l�的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是�pȝ��预先规定好的�Q�在WINDOWS下，栈的大小�?M�Q�也有的说是1M�Q��M��是一个编译时��q��定的常数�Q�，如果甌��的空间超�q�栈的剩余空间时�Q�将提示overflow。因此，能从栈获得的�I�间较小�?例如�Q�在VC6下面�Q�默认的栈空间大��是1M�Q�好像是�Q�记不清楚了�Q�。当�Ӟ��我们可以修改�Q�打开工程�Q�依�ơ操作菜单如下：Project->Setting->Link�Q�在Category 中选中Output�Q�然后在Reserve中设定堆栈的最大值和commit�?br>注意�Q�reserve最��gؓ4Byte�Q�commit是保留在虚拟内存的页文�g里面�Q�它讄��的较大会使栈开辟较大的��|��可能增加内存的开销和启动时间�?/p>

堆（heap�Q? 堆是向高地址扩展的数据结构，是不�q�箋的内存区域（�I�闲部分用链表串联�v来）。正是由于系�l�是用链表来存储�I�闲内存�Q�自然是不连�l�的�Q�而链表的遍历方向是由低地址向高地址。一般来讲在32位系�l�下�Q�堆内存可以辑ֈ�4G的空��_��从这个角度来看堆内存几乎是没有什么限制的。由此可见，堆获得的�I�间比较灉|��Q�也比较大�?/p>

4、分配空间的效率�?br>栈（stack�Q?栈是机器�pȝ��提供的数据结构，计算��Z��在底层对栈提供支持：分配专门的寄存器存放栈的地址�Q�压栈出栈都有专门的指��o执行�Q�这��决定了栈的效率比较高。但�E�序员无法对其进行控制�?br>堆（heap�Q?是C/C++函数库提供的�Q�由new或malloc分配的内存，一般速度比较慢，而且�Ҏ��产生内存��片。它的机制是很复杂的�Q�例如�ؓ了分配一块内存，库函��C��按照一定的��法�Q�具体的��法可以参考数据结�?操作�pȝ��Q�在堆内存中搜烦可用的��够大��的�I�间�Q�如果没有��够大��的�I�间�Q�可能是�׃��内存��片太多�Q�，��有可能调用�pȝ��功能��d��加程序数据段的内存空��_��q�样��有��Z��分到��_��大小的内存，然后�q�行�q�回。这样可能引发用��h��和核心态的切换�Q�内存的甌��Q�代价变得更加昂��c��显�Ӟ��堆的效率比栈要低得多�?/p>

5、堆和栈中的存储内容
栈（stack�Q?在函数调用时�Q�第一个进栈的是主函数中子函数调用后的下一条指令（子函数调用语句的下一条可执行语句�Q�的地址�Q�然后是子函数的各个形参。在大多数的C�~�译器中�Q�参数是由右往左入栈的�Q�然后是子函��C��的局部变量。注意：静态变量是不入栈的�?当本�ơ函数调用结束后�Q�局部变量先出栈�Q�然后是参数�Q�最后栈��指针指向最开始存的地址�Q�也��是��d��C��子函数调用完成的下一条指令，�E�序��p��点��l�运行�?br>堆（heap�Q?一般是在堆的头部用一个字节存攑֠�的大��，堆中的具体内�Ҏ��E�序员安排�?/p>

6、存取效率的比较
�q�个应该是显而易见的。拿栈上的数�l�和堆上的数�l�来��_��

void main()
{
int arr[5]={1,2,3,4,5};
int *arr1;
arr1=new int[5];
for (int j=0;j<=4;j++)
{
arr1[j]=j+6;
}
int a=arr[1];
int b=arr1[1];
}

上面代码中，arr1�Q�局部变量）是在栈中�Q�但是指向的�I�间��在堆上�Q�两者的存取效率�Q�当然是arr高。因为arr[1]可以直接讉K��Q�但是访问arr1[1]�Q�首先要讉K��数组的�v始地址arr1�Q�然后才能访问到arr1[1]�?/p>

总而言之，�a�而��M��Q?br>堆和栈的区别可以用如下的比喻来看出：
使用栈就象我们去饭馆里吃饭，只管点菜�Q�声明变量）、付钱、和吃（使用�Q�，吃饱了就赎ͼ�不必理会切菜、洗菜等准备工作和洗��、刷锅等扫尾工作�Q�他的好处是快捷�Q�但是自由度��?br>使用堆就象是自己动手做喜�Ƣ吃的菜��_��比较�ȝ��Q�但是比较符合自��q��口味�Q�而且自由度大

luis 2011-02-14 01:14 发表评论

C++对象数组作�ؓ�c�L��员的问题

luis — Sun, 13 Feb 2011 17:08:00 GMT

例如�Q?br>class ObjectB{};

class ObjectA{
public:
ObjectB array[5];//对象数组作�ؓ�cȝ��成员
}

那样的话对象数组的初始化会变得很�ȝ��Q?br>因�ؓ数组名不能作为左��|��所以不可以指针传递的方式赋倹{�?br>而且不能通过参数列表�Q�构造函数后面加一个冒��P��的方式初始化�Q?br>所以只能让�c�ObjectA自动调用�c�ObjectB的无参构造函�?
---------------

#include <iostream.h>
#include "stdlib.h"
class   ObjectB{
public:
    int a;
public:
    ObjectB(int m=0)
    {
        a=m;
    }
};
class   ObjectA{
public:
        ObjectB   Array[5];
public:
        ObjectA(int   *p)
        {
            Array[0]=ObjectB(p[0]);
            Array[1]=ObjectB(p[1]);
            Array[2]=ObjectB(p[2]);
        }
};

int main()
{
    int p[5]={0,2,2,3,4};
    ObjectA am=ObjectA(p);
    cout<<am.Array[1].a<<endl;
    return 0;
}

---------------

我们可以使用替代方式�Q?br>class A{};

classB{
public:
A*a;//A�c�d��的指针作为类的成�?br>}
同样带来很大的问题，
�Q?�Q�浅拯��Q�深拯��的问题，除非重蝲拯��构造函敎ͼ��c�B才能实现深拷贝，因�ؓ成员中有指针�Q�所以无法简单的用拷贝构造函数生成一个新对象�Q�而用无参构造函数生成的新对象也会有问题�Q�因为里面的指针一般都默认为NULL了�?br>
重蝲拯��构造函数的时候需要申请一定长度的内存�Q�将拯��对象的指针所指向的空间拷贝到新申��L��I�间�Q�再�q�行操作。注意申请后要释放�?br>一个拷贝构造函数的例子

SparseMatrix::SparseMatrix(const SparseMatrix&s)
    {
      Rows=s.Rows;
   Cols=s.Cols;
   Count=s.Count;
   smArray=new Trituple[6];
//此处�q�需要复制对�?/span>
    }

----------------------
补充知识�Q?br>------------------http://www.ksarea.com/articles/20070829_memory-partition-stack-heap-difference.html

C/C++应该是大学里最先接触的�~�程语言�Q�它们的重要性不�a�而喻。但是我始终��q��“数组名就是指�?#8221;的错误信条到现在�Q�可能是因�ؓ大学老师错误的讲解��我一直保留着�q�种误解。指针是C/C++语言的特�Ԍ��而数�l�名与指针有太多的相��|��甚至很多时候，数组名可以作为指针��用，所以也隑օ�在学习中��两者�؜淆。这里介�l�下指针和数�l�名的区�?

1.指针和数�l�名占据的内存空间大��不一��P��如下�E�序1�Q?br>
char str[10];
char *pstr=str;
cout<<
cout<

�W�一行输出结果是�Q?0�Q�第二行输出�l�果是：4

从这里我们可以看出：数组名对应着�Q�而不是指向）一块内存（数组所占的内存区域�Q�或者说是指代数�l�这�U�数据结构，其地址与容量在生命期内保持不变�Q�只有数�l�的内容可以改变。指针对应着一个占�?个字节（Win32�Q�的内存区域�Q�而指向这4个字节所存储的地址所对应的内存单元，它可以指向�Q意类型的内存块。因此，sizeof(str)��gؓ数组占据的内存空间大��即10个字节，而sizeof(pstr)��gؓ指针的值占据的内存�I�间大小�?个字节�?/strong>

2.数组名不是指针，但是在一定的情况下�{换�ؓ指代数组的首地址的指针，而这个数�l�名转�ؓ的指针只能是指针帔R��?br>在以下两�U�情况下才能�q�行�q�种转换�Q?br>a.在程�?�W�二行代码中�Q�将数组名直接赋值给指针�Q�此时数�l�名转换为指向数�l�的首单元的帔R��指针�?br>b.直接��数�l�名作�ؓ指针形参的时候，数组名则转换为指向数�l�的首单元的帔R��指针�q�行传递，如下�E�序2�Q?br>
void fun(char str[])
{
cout<<
str++;
}
void main()
{
…
char str1[5];
fun(str1);
…
}

注意�Q�数�l�名作�ؓ函数形参�q�行传递时�Q�在子函��C��内，它已�l�不再是一个指针常量，而是变成一个真正的指针�Q�可以进行增减等操作�Q�可以被修改。所以程�?中子�E�序�W�一条语句输出的sizeof(str)的��gؓ4.

既然数组名可以被看作指针帔R��Q�而常量是不能修改的，那么如下代码是不允许的：

char str[10];
str++;

但如下代码则合法的：

char str[10];
char *pstr=str;
pstr++;

3.使用指针讉K��数组和��用数�l�名讉K��数组本质不同�?br>例如�Q?br>
char str[7]=”ksarea”;
char *pstr=str;
cout<<<

其中str[3]和pstr[3]�q�回的都是字�W?#8217;r'�Q�但是编译器产生的执行代码却不一栗��对于str[3]�Q�执行代码是从str开始，向后�U�d��两个字节�Q�然后取出其中的字符�Q�而对于pstr[3]�Q�执行代码是从pstr中取出地址�Q�然后在其上�?�Q�然后取出对应内存中的字�W��?/strong>当然�Q�如果pstr是指向int型的指针�Q�那么pstr[3]的处理过�E�是从pstr中取出地址�Q�然后在其上加上3*sizeof(int)�Q�最后取出对应内存中的字�W�，其他的数据类型一�ơ类推�?

luis 2011-02-14 01:08 发表评论

Java 命名规范zt

luis — Tue, 21 Dec 2010 08:44:00 GMT

完全版java规范�Q?a >http://www.huihoo.org/code/java_code_conventions.html#71

luis 2010-12-21 16:44 发表评论

luis — Sun, 19 Dec 2010 13:41:00 GMT
switch(表达�?
{
      case 帔R��表达�?:
         语句1;
      break;

      case 帔R��表达�?:
         语句2;
      break;

……
      case 帔R��表达式n:
         语句n;
      break;

      default:
         语句n+1;
      break;
}

luis 2010-12-19 21:41 发表评论

argmax

luis — Sun, 19 Dec 2010 06:58:00 GMT
argmax{f(x,y): x属于X}是f(x,y)在X上达到最大值时的x��|�� q�个x值是y的函敎ͼ�于是��?x(y):=argmax{f(x,y): x属于X}

luis 2010-12-19 14:58 发表评论

luis — Sat, 18 Dec 2010 16:56:00 GMT

本文来自CSDN博客http://blog.csdn.net/pointbin/archive/2006/01/12/576957.aspx

在java.lang.Math中有个Math.random()�Ҏ��Q�它可以产生0-1之间�Q�包�?但不包括1�Q�的��L��数

在Java中我们可以��用java.util.Random�c�L��产生一个随机数发生器。它有两�U��Ş式的构造函敎ͼ�分别是Random()和Random(long seed)。Random()使用当前旉��即System.currentTimeMillis()作�ؓ发生器的�U�子�Q�Random(long seed)使用指定的seed作�ؓ发生器的�U�子�?/p>
        随机数发生器(Random)对象产生以后�Q�通过调用不同的method�Q�nextInt()、nextLong()、nextFloat()、nextDouble()�{�获得不同类型随机数�?/p>
       1>生成随机�?br>           Random random = new Random();
           Random random = new Random(100);//指定�U�子�?00
           random调用不同的方法，获得随机数�?br>           如果2个Random对象使用相同的种子（比如都是100�Q�，�q�且以相同的��序调用相同的函敎ͼ�那它们返回值完全相同。如下面代码中两个Random对象的输出完全相�?br>          import java.util.*;
          class TestRandom {
                public static void main(String[] args) {
                     Random random1 = new Random(100);
                     System.out.println(random1.nextInt());
                     System.out.println(random1.nextFloat());
                     System.out.println(random1.nextBoolean());
                     Random random2 = new Random(100);
                     System.out.println(random2.nextInt());
                     System.out.println(random2.nextFloat());
                     System.out.println(random2.nextBoolean());
                }
            }

        2>指定范围内的随机�?br>             随机数控制在某个范围�?使用模数�q�算�W?
            import java.util.*;
                 class TestRandom {
                      public static void main(String[] args) {
                           Random random = new Random();
                           for(int i = 0; i < 10;i++) {
                               System.out.println(Math.abs(random.nextInt())%10);
                           }
                      }
                 }
             获得的随机数有正有负的，用Math.abs使获取数据范围�ؓ非负�?/p>
       3>获取指定范围内的不重复随机数
            import java.util.*;
            class TestRandom {
                  public static void main(String[] args) {
                       int[] intRet = new int[6];
                       int intRd = 0; //存放随机�?br>                       int count = 0; //记录生成的随机数个数
                       int flag = 0; //是否已经生成�q�标�?br>                       while(count<6){
                            Random rdm = new Random(System.currentTimeMillis());
                            intRd = Math.abs(rdm.nextInt())%32+1;
                            for(int i=0;i                                if(intRet[i]==intRd){
                                    flag = 1;
                                    break;
                                }else{
                                    flag = 0;
                                }
                            }
                            if(flag==0){
                                intRet[count] = intRd;
                                count++;
                            }
                   }
                  for(int t=0;t<6;t++){
                      System.out.println(t+"->"+intRet[t]);
                  }
               }
            }

luis 2010-12-19 00:56 发表评论

joj 1097 System overload �U�瑟芬问�?��单题

luis — Wed, 22 Jul 2009 23:23:00 GMT

题意好理解，旉��上提高不了，��试数据很少可以交表

�?展开

luis 2009-07-23 07:23 发表评论

luis — Tue, 21 Jul 2009 07:18:00 GMT

今天看完一��牛人博文，受益匪浅�Q�小��C��下。原文更详细http://blog.csdn.net/lewsn2008/archive/2008/04/16/2295790.aspx
首先我们呢看一下输入操作的原理�Q?�E�序的输入都建有一个缓冲区�Q�即输入�~�冲区。一�ơ输入过�E�是�q�样的，当一�ơ键盘输入结束时会将输入的数据存入输入缓冲区�Q�而cin�{�输入输出函数直接从输入�~�冲��Z��取数据。正因�ؓcin�{�输入输出函数是直接从缓冲区取数据的�Q�所以有时候当�~�冲��Z��有残留数据时�Q�cin函数会直接取得这些残留数据而不会请求键盘输入�?br>---------------

1�Q�要注意不同的函数是否接受空格符、是否舍弃最后的回�R�W�的问题!

��d��字符�Ӟ��

scanf()以Space�I�格、Enter、Tab�l�束一�ơ输入，不会舍弃最后的回�R�W�（卛_��车符会残留在�~�冲��Z��Q�，�Q�区别读字符串时会清楚）//所以可以用getchar()清除�Q?/p>
getchar()以Enter�l�束输入�Q�也不会舍弃最后的回�R�W�；

��d��字符串时�Q?/p>
scanf()以Space、Enter、Tab�l�束一�ơ输入，会舍弃最后的回�R�W�（区别��d��W�时�Q�和所有的�I�格�{�等�?o:p>

gets()以Enter�l�束输入�Q�空��g��l�束�Q�，接受�I�格�Q�会舍弃最后的回�R�W�！

�W�二�Q��ؓ了避免出��C��q�问题，必须要清�I�缓冲区的残留数据，可以用以下的�Ҏ��解决�Q?/p>
�Ҏ��1�Q�C语言里提供了函数清空�~�冲区，只要在读数据之前先清�I�缓冲区��没问题了！

       �q�个函数是fflush(stdin)�?/p>
�Ҏ��2�Q�自己取出缓冲区里的�D�留数据�?/p>
       scanf("%[^\n]",string);
-------------------------
cin的学�?br>
一. cin<<

该操作符是根据后面变量的�c�d��d��数据�?/p>
输入�l�束条�g   �Q�遇到Enter、Space、Tab键�?�q�个很重要！)

对结束符的处�?�Q�清楚缓冲区中��得输入结束的�l�束�W?Enter、Space、Tab)
(�q�里有一炚w��题，
int i;
char c[100];
cin>>i;
cin.getline(str,100);
cout<如果输入是：12     adjf回�R
输出��先是空格然后adjf�Q?br>如果输入是：12回�Radjf回�R
输出��是adjf.
看来cin>>要在�q�用�Ӟ��比如cin>>a>>b;或者cin>>a;cin>>b消除�I�格能力才体现�?br>)

二．cin.get()

该函数有三种格式�Q�无参，一参数�Q�二参数

即cin.get(), cin.get(char ch), cin.get(array_name, Arsize)

        �Q�i�Q�读取字�W�的情况�Q?/p>
输入�l�束条�g�Q�Enter键（遇空��g��l�束�Q?/p>
对结束符处理�Q�不丢弃�~�冲��Z��的Enter

cin.get() �?cin.get(char ch)用于��d��字符�Q�他们的使用是相似的�Q?/p>
卻I��ch=cin.get() �?cin.get(ch)是等��L��?br>

��试�E�序�Q?br>#include

using namespace std;

int main()

{

       char c1, c2;

       cin.get(c1);

       cin.get(c2);

       cout<
       cout<<(int)c1<<" "<<(int)c2<
     return 0;

}

��试一输入�Q?/p>
a[Enter]

输出:

a

97 10

【分析】会发现只执行了一�ơ从键盘输入�Q�显然第一个字�W�变量取�?a', �W�二个变量取的是Enter(ASCII��gؓ10)�Q�这是因��函数不丢弃上�ơ输入结束时的Enter字符�Q�所以第一�ơ输入结束时�~�冲��Z��D�留的是上次输入�l�束时的Enter字符�Q?/p>

��试二输入：

a b[Enter]

输出�Q?/p>
a

97 32

【分析】显然第一个字�W�变量取�?a', �W�二个变量取的是Space(ASCII��gؓ32)。原因同上，没有丢弃Space字符�?/p>
            �Q�ii�Q�读取字�W�串的情况：

cin.get(array_name, Arsize)是用来读取字�W�串的，可以接受�I�格字符�Q�遇到Enter�l�束输入�Q�按照长�?Arsize)��d��字符, 会丢弃最后的Enter字符�?/p>                       �Q�i i i�Q�cin.getline()
cin.getline() �?cin.get(array_name, Arsize)的读取方式差不多�Q�以Enter�l�束�Q�可以接受空格字�W�。按照长�?Arsize)��d��字符, 会丢弃最后的Enter字符�?/p>
但是�q�两个函数是有区别的�Q?/p> cin.get(array_name, Arsize)
当输入的字符串超长时�Q�不会引起cin函数的错误，后面的cin操作会��l�执行，只是直接从缓冲区中取数据。但是cin.getline()

当输入超长时�Q�会引�vcin函数的错误，后面的cin操作��不再执行。（具体原因��在下一部分"cin的错误处�?中详�l�介�l�）

------------
cin的错误处�?br>

�E�序执行时有一个标志变量来标志输入的异常状态，其中有三位标志位分别用来标志三种异常信息�Q�他们分别是�Q?/span>failbit�Q?/span>eofbit�Q?/span>badbit。这三个标志位在标志变量中是�q�样分配的：

____________________________________

|     2     |     1    |     0     |

| failbit | eofbit |   badbit |

|___________|__________|___________|

看一下这几个标志位的作用(引用msdn)�Q?/span>

badbit, to record a loss of integrity of the stream buffer.

eofbit, to record end-of-file while extracting from a stream.

failbit, to record a failure to extract a valid field from a stream.

In addition, a useful value is goodbit, where no bits are set.

接下来我么看几个ios�cȝ��数据定义(引用msdn)�Q?/span>

typedef T2 iostate;

static const iostate badbit, eofbit, failbit, goodbit;

�q�里ios�c�d��义了�q�四个常�?/span>badbit, eofbit, failbit, goodbit�Q�其实这四个标志帔R��是取对应标志位的掩码，也即输入的四�U�异常情况！

以上四个帔R��对应的取��gؓ�Q?/span>

ios::badbit    001   输入�Q�输出）��出现致命错误，不可挽回

ios::eofbit    010   已经到达文�g��?/span>

ios::failbit   100   输入�Q�输出）��出现非致命错误�Q�可挽回

ios::goodbit   000   ��状态完全正�?/span>, 各异常标志位都�ؓ0

如果出现输入错误�Q�则cin不再工作�Q�我们可以用cin.clear()重置标记位�?span style="FONT-FAMILY: 宋体; mso-ascii-font-family: 'Times New Roman'; mso-hansi-font-family: 'Times New Roman'">
��试�E�序�Q?/span>

#include

using namespace std;

int main ()

{

char ch, str[20];

cin.getline(str, 5);

cout<<"flag1:"<    // 查看goodbit状态，��x��否有异常

cin.clear();                         // 清除错误标志

cout<<"flag1:"<    // 清除标志后再查看异常状�?/span>

cin>>ch;

cout<<"str:"<

cout<<"ch :"<

return 0;

}

��试输入�Q?/span>

12345[Enter]

输出�Q?/span>

flag1:0 // good()�q�回false说明有异�?/span>

flag2:1 // good()�q�回true说明�Q?/span>clear()已经清除了错误标�?/span>

str:1234

ch :5

但是当前一�ơ读取数据出错后�Q�如果缓冲区没有清空的话�Q�重�|�错误标志还不够�Q�要是能��缓冲区的残留数据清�I�Z��好了哦�Q�下面我们再来看一个很重要的函敎ͼ�cin.ignore()
�q�个函数用来丢弃输入�~�冲��Z��的字�W�，�W�一参数定义一个数�Q�第二个参数定义一个字�W�变量�?/span>
例：cin.ignore(5, 'a'); 函数��不断从�~�冲��Z��取一个字�W�丢弃，直到丢弃的字�W�数辑ֈ�5或者读取的字符�?/span>'a'�?/span>

其实该函数最常用的方式是�q�样的，��第一个参数设的非常大�Q�将�W�二个参数设�?/span>'\n'�Q�这样就可以�~�冲��Z��回�R�W�中的所有残留数据，因�ؓ一般情况下前面输入�D�留的数据是没有用的�Q�所以在�q�行��C��ơ输入操作前��缓冲区中所有数据清�I�是比较合理�?/span>

如：cin.ignore(1024, '\n');

------

luis 2009-07-21 15:18 发表评论

joj 1946 compound words

luis — Sun, 19 Jul 2009 02:09:00 GMT

Sample Input

a alien born less lien never nevertheless new newborn the zebra

Sample Output

alien newborn 输入是字典序的，题意��是讲一个单词分成两半，且两半都出现在输入中�Q�则��此单词输出。下面的代码是对每一个单词尝试所有的分拆�Ҏ��Q�一个个��d��找是否拆成的�?/pre>
个是否都存在�Q�如果两个字串都存在�Q�则输出�Q�同时蟩出��@环（否则可能重复输出�Q��?/pre>
其实有更高效的方法，��是到每个单词前面寻找是否有他的字串�Q�比如newborn 前面有new,neverthelsess 前面有never�Q�，有的话，再找后半部分是否在输入中�?/pre>
----

获取子串的方法�?string B = A.substr(start,length);
start为子串在A中的开始位�|?
length为子串的长度

例子
void main()
{
string st="ifn",b;
b=st.substr(0,2);
cout< }
�l�果 if

----

�Ҏ��代码

luis 2009-07-19 10:09 发表评论

获取行输入，一行一个字�W�串

luis — Sat, 18 Jul 2009 08:11:00 GMT
2152: A Special Sorting

Status In/Out TIME Limit MEMORY Limit Submit Times Solved Users JUDGE TYPE

stdin/stdout 3s 8192K 356 152 Standard

Give you a sequence of words, can you sort them in dictionary order?
eg.
yes accidental baby accept accident
In dictionary order, those words should be printed as the following
accept accident accidental baby yes
But we will make an interesting rule this time. See your keyboard or the picture below:
there are ONLY 26 letters in lower-case we will use, and we assume that the letter above is bigger than the letter below, and the left is bigger than the right. For example, 'q' is bigger than 'a', 'c' is bigger than 'v'. So the example at the beginning whill be...
Input and Output
the input will only contain a sequence of words which is less than 1500. the output should print the sorted words each in a single line.
Sample Input

yes accidental baby accept accident

Sample Output

baby accident accidental accept yes

水题啊！
#include
#include
#include
#include
using namespace std;
int Map[27];
struct M{
char s[30];
}S[1500];
char table[26]={'q','w','e','r','t','y','u','i','o','p','a','s','d',
'f','g','h','j','k','l','z','x','c','v','b','n','m'};
bool operator<(M a,M b)
{
int i=strlen(a.s);
int j=strlen(b.s);
if(i j=i;
for(int k=0;k {
  if(Map[(a.s[k])-'a']  return false;
  if(Map[(a.s[k])-'a']>Map[(b.s)[k]-'a'])
  return true;
}
return i==j;//Èç¹ûabcd,abc,abcd}
void search(char key)
{
int i;
for(i=0;i<26;i++)
{
if(key==table[i])
{
  Map[key-'a']=i;
  break;
}
}
}
int main()
{
freopen("s.txt","r",stdin);
freopen("key.txt","w",stdout);
int i;
string t;
memset(S,0,sizeof(S));
for(i=0;i<26;i++)
{
  search('a'+i);
}
i=0;
while(!cin.eof())
   {
cin.getline(S[i++].s,30);//不能用cin>>s;否则runtime error
   }
sort(S,S+i-1);
for(int j=0;j cout< //system("PAUSE");
return   0;
}
奇怪的是在vc上能�?br>string s ;
while(cin>>s)
{};
在dev c++ 上不行�?
后来才发现可�?br>string s ;
while(cin>>s)
{};
但是不能�?memset(S,0,sizeof(S));

luis 2009-07-18 16:11 发表评论

luis — Fri, 17 Jul 2009 15:21:00 GMT

可以用long long�Q�可以不用高�_�ֺ��法�Q�大整数乘法�Q��?br>�?开始遍历到9999999999/n;因�ؓ最多只�?0位。相乘之�U�也应当��于9999999999.

long long  n=9999999999.0;
  long long  m,temp;
  while(cin>>m)
{

    for(int i=1;i<=n/m;i++)
         {
          //判断
         }
}

luis 2009-07-17 23:21 发表评论

joj 1199 求n!最双��一位非零数

luis — Wed, 08 Jul 2009 02:45:00 GMT

求模的思想
#include
#include
#include
using namespace std;

int main()
{
//freopen("s.txt","r",stdin);
//freopen("key.txt","w",stdout);
int n;
int temp;
while(cin>>n)
{
  cout< " ;
  temp=1;
  for(int j=1;j<=n;j++)
  {
   int i=j;
   while(i%10==0)
   {
    i/=10;
   }
   while(i%5==0)
   {
    i/=5;
    temp/=2;
   }

   temp*=i;

  //¼ÆËãÄ©Î»
   temp%=100000;
  }
  while(temp%10==0)
  temp/=10;
  temp%=10;
  cout< }

//system("PAUSE");
return   0;
}
一�U�是分类的思想

#include
#include
using namespace std;

int main()
{
long a[10001]={0,1,2,6,4,2},b[5]={0,2,4,8,6},i,m,n;
for(i=6;i<=10000;i++)
{
m=i%5;
n=i/5;
if(m!=0)
   a[i]=a[i-1]*i%10;
else
   a[i]=b[(n-1)%4+1]*a[n]%10;
}
while(cin>>n)
cout< "< return 0;
}

luis 2009-07-08 10:45 发表评论

joj 1125 spell checker字符串处�?map

luis — Mon, 06 Jul 2009 12:13:00 GMT
Spell Checker

Status In/Out TIME Limit MEMORY Limit Submit Times Solved Users JUDGE TYPE

stdin/stdout 3s 8192K 135 46 Standard

You, as a member of a development team for a new spell checking program, are to write a module that will check the correctness of given words using a known dictionary of all correct words in all their forms.

If the word is absent in the dictionary then it can be replaced by correct words (from the dictionary) that can be obtained by one of the following operations:

deleting of one letter from the word;
replacing of one letter in the word with an arbitrary letter;
inserting of one arbitrary letter into the word.

Your task is to write the program that will find all possible replacements from the dictionary for every given word.
Input
This problem consists of several test cases, each of which is described below:
The first part of each test case contains all words from the dictionary. Each word occupies its own line. This part is finished by the single character '#' on a separate line. All words are different. There will be at most 10000 words in the dictionary.

The next part of the test case contains all words that are to be checked. Each word occupies its own line. This part is also finished by the single character '#' on a separate line. There will be at most 50 words that are to be checked.

All words in the input (words from the dictionary and words to be checked) consist only of small alphabetic characters and each one contains 15 characters at most.

The first line of the input contains an integer N, which is the number of test cases in the input, followed by N test cases described above.
Output
For each test case, first write to the output 'Scenario #k:', where k is the number of test case of input. Then on the next line write to the output exactly one line for every checked word in the order of their appearance in the second part of the test case. If the word is correct (i.e. it exists in the dictionary) write the message: " is correct". If the word is not correct then write this word first, then write the character ':' (colon), and after a single space write all its possible replacements, separated by spaces. The replacements should be written in the order of their appearance in the dictionary (in the first part of the input file). If there are no replacements for this word then the line feed should immediately follow the colon.

Print a blank line after each test case.
Sample Input

1 i is has have be my more contest me too if award # me aware m contest hav oo or i fi mre #

Sample Output

Scenario #1: me is correct aware: award m: i my me contest is correct hav: has have oo: too or: i is correct fi: i mre: more me

启发�Q�map用于查找字符串还是很爽的�?br>
#include<iostream>
#include<cstdlib>
#include<map>
#include<math.h>
#include<string>
using namespace std;
map <string,int> ans;
bool solve(char *s,char *key)
{
    int i=strlen(s);
    int j=strlen(key);
    int num=0;
    if(abs(i-j)>1)
    return false;
    else
    {
        if(i-j==1)//比字�怸�多一�?nbsp;
        {
            for(int k=0;k<j&&num<=2;k++)
            {
                if(s[k+num]!=key[k])
                {
                    num++;
                    k--;
                }
            }
            if(num<=1)
            return true;
            else
            return false;
        }
        if(j-i==1)//比字�怸��一�?nbsp;
        {
            for(int k=0;k<i&&num<=2;k++)
            {
                if(s[k]!=key[k+num])
                {
                    num++;
                  k--;
                }
            }
            if(num<=1)
            return true;
            else
            return false;
        }
        if(i==j)
        {
            for(int k=0;k<i&&num<=2;k++)
            {
                if(s[k]!=key[k])
                num++;
            }
            if(num==1)
            return true;
            else
            return false;
        }
    }
}
  int main()
  {
  freopen("s.txt","r",stdin);
  freopen("key.txt","w",stdout);
  int num,casetime=0;
  int i,j,k;
  cin>>num;
  char s[16];
  char str[10000][16];
  while(num--)
  {
        casetime++;
        cout<<"Scenario #"<<casetime<<":"<<endl;
        ans.clear();
        i=0;
        while(1)
        {
            scanf("%s",&str[i]);
            if(str[i][0]=='#')
              break;
            ans[str[i]]=1;
            i++;
        }
        while(1)
        {
            scanf("%s",&s);
            if(s[0]=='#')
              break;
            if(ans[s]==1)
            {
                cout<<s<<" is correct"<<endl;

            }
            else
            {
                cout<<s<<":";
               for(int j=0;j<i;j++)
              {
                if(solve(s,str[j]))
                  cout<<" "<<str[j];
              }
              cout<<endl;
            }
        }
        cout<<endl;

  }

  //system("PAUSE");
  return   0;
  }

luis 2009-07-06 20:13 发表评论

luis — Fri, 03 Jul 2009 10:04:00 GMT

You have decided that PGP encryptation is not strong enough for your email. You have decided to supplement it by first converting your clear text letter into Pig Latin before encrypting it with PGP.
Input and Output

You are to write a program that will take in an arbitrary number of lines of text and output it in Pig Latin. Each line of text will contain one or more words. A ``word'' is defined as a consecutive sequence of letters (upper and/or lower case). Words should be converted to Pig Latin according to the following rules (non-words should be output exactly as they appear in the input):

Words that begin with a vowel (a, e, i, o, or u, and the capital versions of these) should just have the string ``ay'' (not including the quotes) appended to it. For example, ``apple'' becomes ``appleay''.
Words that begin with a consonant (any letter than is not A, a, E, e, I, i, O, o, U or u) should have the first consonant removed and appended to the end of the word, and then appending ``ay'' as well. For example, ``hello'' becomes ``ellohay''.
Do not change the case of any letter.

Sample Input

This is the input.

Sample Output

hisTay isay hetay inputay.

虽然题目隑ֺ�不是很大�Q�但是对我启发挺大，��到�q�种字符串处理的题，最好就是统一模式�Q?br>                  a=getchar():
                   while(flag)
           {      while()//判断是否�W�合条�g
                 { ----   ,
                        if((a=getchar())==EOF)//获取a=getchar()
                                  flag=0;//判断文�g是否�l�束
                  }
                   while()//判断是否�W�合条�g
                 { ----   ,
                        if((a=getchar())==EOF)//获取a=getchar()
                                  flag=0;//判断文�g是否�l�束
                  }
              }

#include<iostream>
#include<cstdlib>
using namespace std;

  int main()
  {
// freopen("s.txt","r",stdin);
// freopen("key.txt","w",stdout);
  char a;
  int flag=0,e=1,mark;
  string temp;
  char mar;
  a=getchar();
  while (e)
  {
           mark=0;
            while((a>='a'&&a<='z')||(a>='A'&&a<='Z'))
          {
            temp="ay";
             if(flag==0)
            {
                 flag++;
                 if(a=='A'||a=='a'||a=='E'||a=='e'||a=='I'||a=='i'||a=='O'||a=='o'||a=='U'||a=='u')
                 cout<<a;
                 else
                {
                    mark=1;
                    mar=a;
                }
           }
            else
          cout<<a;
          if((a=getchar())==EOF)
                {
                    e=0;
                    break;
                 }
         }
          if(mark==1)
           {
                cout<<mar;
           }
          cout<<temp;
           while(a<'A'||a>'z'||(a>'Z'&&a<'a'))
           {
                cout<<a;
                if((a=getchar())==EOF)
                {
                    e=0;
                    break;
                 }
           }
           flag=0;
  }
  //system("PAUSE");
  return   0;
  }

luis 2009-07-03 18:04 发表评论

joj 2197 perfect set 序偶对称

luis — Fri, 03 Jul 2009 08:43:00 GMT

A perfect point set is a set of points, for every point (x,y) in this set, point (y,x) is also in this set.
Input
There are mutical cases for this problem. For every input case, there is a set. we give you the number of points in this set in the first line, followed by n lines,each give two integers x y.
Output
If this set is a perfect set, you should print "Yes", else you print "No".
Sample Input

4 1 4 4 1 2 5 5 2

Sample Output

Yes

1�Q�这�U�类似稀疏矩�늚�数组对一般不用数�l�存储，用结构体比较�?/pre>
2�Q�排序后比较非常的��y妙�?/pre>
#include #include using namespace std; struct mm{ double a; double b;}M[100000]; bool operator<(mm m1,mm m2) { if(m1.a>num) { memset(M,0,sizeof(M)); temp=0; for(int k=0;k>a>>b; if(ab)//把a和b相等的都��L��? { M[temp].a=b; M[temp].b=a; temp++; } } if(temp%2!=0)cout<<"No"<

luis 2009-07-03 16:43 发表评论

luis — Wed, 01 Jul 2009 02:54:00 GMT
#include
#include
#include
#include
#include
using namespace std;

int main()
{
//freopen("s.txt","r",stdin);
// freopen("key.txt","w",stdout);
int n,m;
int a[12];
int time=0;
while(cin>>n>>m)
{
int i,j;
double k;
memset(a,0,sizeof(a));
time++;
double sum=0.0;
double temp=0.0;
for(i=0;i{
cin>>a[i];
sum+=a[i];
}
sum/=n;
sort(a,a+2*n);//????a[0]????a[2n-1]
for(j=0;j{
k=a[j]+a[2*n-j-1]-sum;
if(k>0)
        temp+=k;
    else
     temp-=k;
    }
    cout<<"Set #"<        cout<<"IMBALANCE = "< }

//system("PAUSE");
return   0;
}
1�Q�设计到减法注意是否是double�c�d��
2�Q�要不要�l�对��|��abs(),include
3,cout<
luis 2009-07-01 10:54 发表评论

欧美成a人片免费看久久,久久国产成人午夜AV影院,国产成人无码精品久久久免费

C++对象数组作�ؓ�c�L��员的问题

Java 命名规范zt

argmax

joj 1097 System overload �U�瑟芬问�?���单题

joj 1946 compound words

Sample Output

获取行输入，一行一个字�W�串

Input and Output

Sample Input

Sample Output

joj 1199 求n!最双���一位非零数

joj 1125 spell checker字符串处�?map

Input

Output

Sample Input

Sample Output

Input and Output

Sample Input

Sample Output

joj 2197 perfect set 序偶对称

Input

Output

Sample Input

Sample Output

joj 1097 System overload �U�瑟芬问�?��单题

joj 1199 求n!最双��一位非零数