这时我们可以使用SetUnhandledExceptionFilter函数，MSDN对函数的描述是这样的

LPTOP_LEVEL_EXCEPTION_FILTER SetUnhandledExceptionFilter(
  LPTOP_LEVEL_EXCEPTION_FILTER lpTopLevelExceptionFilter
);

上面的红字是我做的重点标注，通过注册的回调函数的返回值我们可以控制是否弹出程序崩溃的对话框。

EXCEPTION_EXECUTE_HANDLER 表示结束程序但不弹出崩溃对话框。从宏的拼写上可以认为我处理了这个异常
EXCEPTION_CONTINUE_EXECUTION 表示错误已经被修复，继续执行，这是一个不应该被使用的返回值，因为一个设计良好的程序不会把错误处理放在这个步骤中。
EXCEPTION_CONTINUE_SEARCH 表示结束程序并弹出一个崩溃对话框。从宏的拼写上可以认为我没有处理这个异常，请继续搜索其他的handler

事实上只能有一个回调函数被同时注册，因此如果我们想让所有注册过的回调函数都能执行到的话需要接收SetUnhandledExceptionFilter 的返回值，即the address of the previous exception filter并在回调函数中调用，像这样

LPTOP_LEVEL_EXCEPTION_FILTER g_preFilter;
LONG WINAPI func( PEXCEPTION_POINTERS pExceptionInfo )
{
    //...

    if(g_preFilter)
        return g_preFilter(pExceptionInfo);
    else
        return EXCEPTION_CONTINUE_SEARCH;
}

int main ()
{
    g_preFilter = SetUnhandledExceptionFilter(func);
    ///...
    return 0;
}

我们也可以做成，只在preFilter执行返回EXCEPTION_CONTINUE_SEARCH的时候才处理这个异常

LPTOP_LEVEL_EXCEPTION_FILTER g_preFilter;
LONG WINAPI func( PEXCEPTION_POINTERS pExceptionInfo )
{
    LONG res;
    if(g_preFilter==NULL || (res = g_preFilter(pExceptionInfo)) == EXCEPTION_CONTINUE_SEARCH)
    {
        //...
        return EXCEPTION_CONTINUE_SEARCH;
    }
    else
    {
        return res;
    }
}

int main ()
{
    g_preFilter = SetUnhandledExceptionFilter(func);
    ///...
    return 0;
}

这要根据实际的应用情况决定。

关于如何保留下当时的调用堆栈等信息是个复杂的主题，不过已经有前辈做过这件事了。

附件中包含一个异常处理机制，会在程序崩溃时生成一份报告文件和一份DUMP文件。

WheatyExceptionReport.rar

目前的阴影算法大致可以分为以下三类：基于ray tracing，基于shadow volume，基于shadow map。shadow map因其易于实现，算法复杂度与场景复杂度无关等优点被广泛应用，但是shadow map有alias（走样、锯齿）的问题。为解决这个问题，产生了诸多对标准shadow map的改进办法。

Shadow map的alias问题可以分为两类：Perspective alias和Project alias。Project alias是因为当光照方向与物体表面夹角比较小时，使得多个pixel对应Shadow map中一个texel，产生alias问题，此类alias目前是个困难问题，针对这类alias的研究有Resolution-Matched SMs (Lefohn et al. 2007), Irregular Z-Buffer (Johnson et al.2005)，但都需要承受很大性能损失。Perspective alias产生的原因是透视投影会产生近大远小的效果，这使得近处物体的多个pixel可能对应着Shadow map中一个texel, 产生alias问题。相比其他流行的shadow map技术，如perspective shadow maps (PSMs) (Stamminger and Drettakis 2002), light-space perspective shadow maps (LiSPSMs) (Wimmer et al. 2004) and trapezoidal shadow maps (TSMs) (Martin and Tan 2004)，本文介绍的Parallel-Split Shadow Maps (PSSMs) (Zhang et al. 2007 and Zhang et al. 2006) 思想相对直观，实现也比较简单，并且不需要根据不同类型的关于和特殊的位置对映射进行任何特化处理，而且可以和其他的shadow map算法结合使用。

PSSMs的基本思路就是把摄像机的视域体按照Z的范围平行分割成多个部份，每个部分称为一个子视域体，分别为对每个子视域体生成Shaodw Map，在渲染场景时根据Z值选择最适合的Shaodw Map进行采样。

二．算法

PSSMs算法的主要步骤如下：

1) 将摄像机视域体按深度范围划分成多个子视域体{V1,V2,...,Vm}。

2) 根据各相机子视域体分别计算各光源子视域体{W1,W2,...,Wm}。

3) 生成阴影图，将Wi包含的阴影投射对象渲染到阴影图Ti中。

4) 综合场景阴影效果，Vi中的像素采样Ti进行阴影判断。

Step1. 分割摄像机视域体

如何分割视域体对PSSMs算法生成的阴影质量有着重要影响，若将视域体划分为m层，则摄像机空间下场景的划分平面深度值Ci可以通过

求得，其中f,n分别表示V的远近裁剪面，和代表2种划分策略，参数用以调节他们的比例，分层策略的详细解释见参考文献[1]。

Step2. 计算光源视域体及其变换矩阵

在计算子视域体Wi的view-projection矩阵之前，我们必须找到分割视域体Vi在光空间下的轴对齐包围盒。然后，我们引入cropMatrix的概念，cropMatrix是一个在投影空间内对规则观察体进行缩放和平移的矩阵，最终我们在以光源为视点进行阴影图Ti的渲染时使用的view-projection变换矩阵是

lightViewMatrix * lightProjMatrix * cropMatrix

当lightProjMatrix为正交投影时(对于平行光)，cropMatrix的作用相当于在世界空间内平移和缩放以光源为视点的视域体；

当lightProjMatrix为透视投影时(对于点光源)，cropMatrix的作用相当于在世界空间内绕光源旋转和缩放以光源为视点的视域体。

这正好符合平行光和点光源的特性，所以cropMatrix在平行光和点光源下都是正确的。

我们使用如下函数来计算cropMatrix，

Matrix4f CalcCropMatrix( Frustum splitFrustum, Matrix4f matViewProj);

其中，

参数 splitFrustum 是某个子视域体Vi。

参数 matViewProj 是一个未经修剪的view-projection矩阵(即视矩阵和投影矩阵的复合)

函数返回一个cropMatrix使得 matViewProj * cropMatrix所对应的规则观察体恰可以包住splitFrustum的轴对齐包围盒（AABB）。

函数实现如下:

Matrix4f CalcCropMatrix( Frustum splitFrustum, Matrix4f matViewProj) { // 计算视域体splitFrustum在matViewProj空间下的轴对齐包围盒 BoundingBox cropBB = CalcAABB(splitFrustum, matViewProj); // 使用默认的近裁剪面 cropBB.min.z = 0.0f; // 计算缩放和偏移值 float scaleX, scaleY, scaleZ; float offsetX, offsetY, offsetZ; scaleX = 2.0f / (cropBB.max.x - cropBB.min.x); scaleY = 2.0f / (cropBB.max.y - cropBB.min.y); offsetX = -0.5f * (cropBB.max.x + cropBB.min.x) * scaleX; offsetY = -0.5f * (cropBB.max.y + cropBB.min.y) * scaleY; scaleZ = 1.0f / (cropBB.max.z - cropBB.min.z); offsetZ = -cropBB.min.z * scaleZ; return Matrix4f(scaleX, 0.0f, 0.0f, 0.0f, 0.0f, scaleY, 0.0f, 0.0f, 0.0f, 0.0f, scaleZ, 0.0f, offsetX, offsetY, offsetZ, 1.0f); }

这里有几点需要说明的，cropBB.min.z = 0.0f表示使用默认的近裁剪面，即生成的cropMatrix不对参数matViewProj所定义的近裁剪面进行调整，如果使用由包围盒计算出的近裁剪面会导致从由matViewProj所定义的视点到包围盒之间的阴影投射体不会被渲染到阴影图上，那么其所产生的阴影就不会出现在包围盒内的物体上，如图2-3所示，Caster的阴影应该出现在Vi内的物体上，但Caster不在Vi所对应的AABB内。

还有一点需要注意的是应该保证splitFrustum 不会出现在matViewProj所对应的投影空间的Z轴的副半轴，否则生成cropMatrix将不正确。

Step3. 生成分段阴影图

在阴影图生成方面，在DX10上是可以优化到渲染一次的。而在DX9上如果将视域体分成N段的话需要渲染N次来生成N张不同子视域体的阴影图。如下图2-4：

在DX9上使用GPU加速的渲染流程大致如下：

Matrix4f lightViewProjMatrix[numSplits]; //生成光源深度图 for(int i=0;i<numSplits;i++) { //设置阴影图为RenderTarget GetRenderDevice()->BeginRenderToTargets(m_pTexShadowMap[i])); GetRenderDevice()->Clear(); //计算子视域体 splitFrustum = camera->CalculateFrustum(splitPos[i], splitPos[i+1]); //计算cropMatrix cropMatrix = CalcCropMatrix(splitFrustum, lightViewMatrix * lightProjMatrix); lightViewProjMatrix[i] = lightViewMatrix * lightProjMatrix * cropMatrix; //以lightViewMatrix * lightProjMatrix * cropMatrix为ViewProj变换渲染阴影投射体 RenderCasters(casters, lightViewProjMatrix[i]); GetRenderDevice()->EndRenderToTargets(); }

Step4. 合成场景阴影效果

for(int i=0;i<numSplits;i++) { //设置各个子视域体的光源ViewProj矩阵 GetRenderDevice()->ShaderSetConstant(ShaderStage::VERTEX_SHADER_STAGE, LIGHT_VPMATRIX_REGISTER+i*4, &lightViewProjMatrix[i]); //设置各个子视域体生成的阴影图 GetRenderDevice()->ShaderSetConstant(ShaderStage::PIXEL_SHADER_STAGE, SHADOWMAP_REGISTER+i, m_pTexShadowMap[i]); } //以摄像机的ViewProj变换渲染阴影接收体 RenderReivers(receivers, camera->viewMatrix * camera->projMatrix);

Vertex and Pixel Shaders for Synthesizing Shadows in DirectX 9

struct VS_IN { float3 ObjPos : POSITION; float2 ObjUV : TEXCOORD2; }; struct VS_OUT { float4 ProjPos : POSITION; float2 ObjUV : TEXCOORD2; float viewZ : TEXCOORD3; float4 texCoordProj[3] : TEXCOORD4; }; float4x4 matWorld : register(c0); float4x4 matView : register(c4); float4x4 matProj : register(c8); float4x4 matLightVP[3] : register(c12); VS_OUT main( VS_IN In ) { float4 wPosition = mul(float4(In.ObjPos.xyz, 1.0f), matWorld); float4 vPosition = mul(wPosition, matView); VS_OUT Out; Out.ProjPos = mul( vPosition, matProj ); Out.ObjUV = In.ObjUV; Out.viewZ = vPosition.z; float4x4 matLightViewport = float4x4( 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, -0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.5f + 0.5f / 512.0f, 0.5f + 0.5f / 512.0f, 0, 1.0f ); for(int i=0;i<3;i++) { Out.texCoordProj[i] = mul( wPosition, matLightVP[i] ); Out.texCoordProj[i] = mul( Out.texCoordProj[i], matLightViewport); } return Out; }

struct PS_IN { float2 ObjUV : TEXCOORD2; float viewZ : TEXCOORD3; float4 texCoordProj[3] : TEXCOORD4; }; sampler2D g_Tex : register(s0); sampler2D g_tShadowMap[3] : register(s1); float4 main( PS_IN In ) : COLOR { float lightIntensity = 1.0; for(int i=0;i<3;i++) { if(In.viewZ < splitPlane[i]) { lightIntensity = tex2Dproj(g_tShadowMap[i], In.texCoordProj[i]).x; } } float4 COLOR_IN_SHADOW, COLOR_IN_LIGHT; COLOR_IN_SHADOW.rgba = float4(0.2,0.2,0.2,1.0); COLOR_IN_LIGHT.rgba = float4(1.0,1.0,1.0,1.0); float4 tex = tex2D(g_Tex, In.ObjUV); tex *= lerp(COLOR_IN_SHADOW, COLOR_IN_LIGHT, lightIntensity); return tex; }

三．可能的优化

·结合使用Variance Shadow Maps和Gaussian Blur可进一步软化阴影边缘

·正反Culling渲染2次取平均深度可以帮助解决Shadow Acne & Peter Panning

·将阴影图纹理打包，使用TextureArray或者拼到一张2D Texture上，可以减少PS的分支
参考文献：

[1] Zhang F, Sun H Q, Xu L L, et al. Hardware-accelerated parallel-split shadow maps[J]. International Journal of Image and Graphics, 2008.8(2): 223-241

[2] Zhang F, Sun H Q, Nyman O. Parallel-Split Shadow Maps on Programmable GPUs. GPU Gems 3 - Chapter 10, 2007: 203-238

int main()
{
 int n;
 while(scanf("%d",&n)!=EOF){
  int x=1;
  int i=1;
  while(x%n){
   x=(x*10+1);
   i++;
  }
  printf("%d\n",i);
 }
}
但是sample都过不了，因为sample中就有一个输出是12，显然int不够长，然后我问了金XX，金告诉我不要大整数，大概10分钟后我又问了一次……，然后他告诉我用到了“同余”，其实我本来也不是不知道，但是没想到可以这样用，也许第一次碰到这样的题目，看了数论的书，
“a,b关于模m同余”是等价关系，记作a=b(mod m)
若a1=a2(mod m),且b1=b2(mod m)，则a1+b1=a2+b2(mod m)
若a1=a2(mod m),且b1=b2(mod m)，则a1*b1=a2*b2(mod m)

回到题目x%n==0就是x=0(mod n)
若x'=x(mod n),且10=10(mod n)，且1=1(mod n)，则x'*10+1=x*10+1(mod n)
因此，不妨将x(mod n)记做x，这样就可以避免超过int的范围了

#include <windows.h>
#include <tlhelp32.h>
#include <stdio.h>
#include <string.h>

//  Forward declarations:

int main( int argc, char *argv[] )
{
  HANDLE hProcessSnap;
  HANDLE hProcess;
  PROCESSENTRY32 pe32;
//  BOOL itruns;

  if (argc>1) {
   //initialize runing flag
//   itruns=0;

   // Take a snapshot of all processes in the system.
   hProcessSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS, 0 );

   // Set the size of the structure before using it.
   pe32.dwSize = sizeof( PROCESSENTRY32 );

   // Retrieve information about the first process,
   // and exit if unsuccessful
   Process32First( hProcessSnap, &pe32 );
   // Now walk the snapshot of processes
   do
   {
 if (!strcmp(argv[1], pe32.szExeFile)) {
//  itruns=1;
  if (argc>2) {
   hProcess = OpenProcess( PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID );
   TerminateProcess( hProcess, (DWORD) -1 );
  } else {
   printf( "runs" );
   return 0;
  }
 }
   } while( Process32Next( hProcessSnap, &pe32 ) );
//   if (!itruns) printf( "no" );
  } else {
   printf ("Use: pskill processname [c]\nc says to kill the process. It returns 'runs' if the process exists.");
  }
  return 1;
}

#include <iostream>
#include <vector>
#include <cmath>
#include <stdlib.h>

#define PI 3.141592653589793238
using namespace std;

//过原点的抛物线y=ax^2+bx
class paowuxian{
public:
    double a;
    double b;
};   

class point{
public:
    double x;
    double y;
};

//返回过原点，点a,点b，的抛物线
//前提条件：三点不共线
paowuxian workout(point a,point b)
{
    paowuxian res;
    double a11,a12,a21,a22,b1,b2;
    a11=a.x*a.x;
    a12=a.x;
    a21=b.x*b.x;
    a22=b.x;
    b1=a.y;
    b2=b.y;
    res.a=(b1*a22-b2*a12)/(a11*a22-a21*a12);
    res.b=(a11*b2-a21*b1)/(a11*a22-a21*a12);
    return res;
}   

//点p_a在抛物线pwx上方时返回真  
bool operator > (point p_a,paowuxian pwx)
{
    return (p_a.y > (pwx.a*p_a.x+pwx.b)*p_a.x);
}   

int main()
{
    int n;
   vector<point> Vec;
   while(scanf("%d",&n)!=EOF){
       point point_tmp;
       point_tmp.x=point_tmp.y=0.0;
       paowuxian pwx;
       Vec.clear();

       //把点压入动态数组
       for(int i=0;i<n;++i){
           double y,dx;
           scanf("%lf %lf",&y,&dx);
           point_tmp.y=y;
           Vec.push_back(point_tmp);//这里会取到一些显然不必要的点，有待改进
           point_tmp.x+=dx;
           Vec.push_back(point_tmp);
       }
      
       //为抛物线赋初值
       //pwx=workout(Vec.front(),Vec.back());
       pwx=workout(Vec[1],Vec.back());//目前Vec[0]是x轴上的点不能取，改进后需修改
      
       //如果有点在当前抛物线上方，则重新计算抛物线，最终包含所有点在下方
       for(int i=1;i<Vec.size()-1;i++){
           if(Vec[i]>pwx){//注释1
               pwx=workout(Vec[i],Vec.back());
           }   
       }
       //printf("%lf,%lf\n",pwx.a,pwx.b);
       point highest;//抛物线顶点
       highest.x=Vec.back().x/2;
       highest.y=highest.x*(highest.x*pwx.a+pwx.b);
       double angle_r,angle_d;//仰角的弧度表示和角度表示
       angle_r=atan(highest.y*2/highest.x);
       angle_d=angle_r*180/PI;
       //printf("%.2lf\n",angle);
       double vx,vy,velocity;
       vy=sqrt(2.0*9.8*highest.y);
       velocity=vy/sin(angle_r);
       printf("%.2lf %.2lf\n",angle_d,velocity);
   }
  return 0;
}

在VC++6.0下得到输出
7 2 1
1245028 1245032 1245052

在DEV-CPP4.9.9.0下得到输出
 7 2 8
 2293572 2293576 2293596
总结：
1.数组可以使用负整数下标。并且此时依然有
*(p+k)和p[k]等价，无论k是正整数还是负整数。

2.对局部自动变量的空间分配是编译器决定的，不一定连续定义的变量空间就是连续的。

PS：以前看到过一个例子，大概是

说这个循环因为对数组的越界访问会造成死循环，其实是不一定的，越界访问无庸置疑，但是不是造成死循环，是依赖编译器对变量的空间分配而决定的

在早期的C++中，inline关键字通常被认为是劝说程序员使用setters和getters代替直接访问数据成员的一种方式。今天，大多数的编译器都比一般程序员更加清楚什么函数更适合inlining。此外，inline的使用可以导致繁重的维护问题，敏感的bugs和无用功。

一个典型的函数由一行代码组成。定义它inline在开始的时候感觉很合理：

classFile
{
public:
intget_descriptor()const;
//..
private:
int_fd;
//..
};

inlineintFile::get_descriptor()const
{return_fd;}//fine,aslimfunctionbody

考虑到由于设计的改变，移动到新的系统或者OS中等等，get_descriptor()现在包含的15行代码。很显然，不能再定义inline。那么，维护者会记得将inline从这个函数的定义中移动吗？

Inline和静态连接

另外一个问题在被代码库使用的inline函数中浮现。许多程序库使用的是静态连接，库会在没有终端用户改变他们的程序的情况下进行代码改变。但是，如果一个inline函数的改变将不能维护二进制文件的兼容性，在这种情况下，用户必须重新编译他们的代码。就是说，例如一个exe使用到了一个lib，lib在保持所有接口含义的情况下改变了实现方法，如果应用的代码没有任何变化那么只需要用新的lib重新link即可，但是如果lib中有inline函数而inline函数发生了变化，那么exe不得不重新编译，这有悖lib的意义，而且容易引起因编译器检查错误而遗漏重编。

Inline使用规则

使用inline的危险超过了它的好处，如果你的代码需要被优化，通常使用专业的模型来优化他们。使用inline仅仅是代码部分需要被优化的时候，并且你发觉只有inline才可以改变它们的性能时才使用。除此之外，避免使用inline。

本文作者：DannyKaley是一个有着14年丰富经验的系统分析师和软件工程师。他擅长C++和面向对象的程序设计。