You definitely can't dynamically allocate memory in HLSL. But you also don't need to. What you can do is declare a constant buffer in your shader containing an array of your "PointLight" structures with size equal to some maximum number of lights (you can go for something big like 128 if you'd like), and then have another variable in your constant buffer containing the actual number of lights that you want rendered. So your shader would look something like this:

struct PointLight
{
float4 LightColor;
float3 LightPosition;
};

static const uint MaxLights = 128;

cbuffer Lights : register(cb0)
{
PointLight Lights[MaxLights];
uint NumLights;
}

float4 PSMain(in PSInput input) : SV_Target0
{
float3 lighting = 0.0f;
for(uint i = 0; i < NumLights; ++i)
lighting += ApplyPointLight(Lights);
}


As far as the C++ side of things go, the easiest way to manage this is to have a C++ structure that exactly matches the memory layout of your constant buffer. So you can declare a C++ version of your PointLight struct, as well as a C++ version of the entire constant buffer structure. The one thing that you need to watch out for is in HLSL your PointLight structure will get padded out to some multiple of 16 bytes (float4 size), so you'll need to do the same in C++. Something like this should work:

struct PointLight
{
D3DXVECTOR4 LightColor;
D3DXVECTOR3 LightPosition;
float _Padding;
};

static const UINT32 MaxLights = 128;

struct LightConstantBuffer
{
PointLight Lights[MaxLights];
UINT32 NumLights;
};


Then all you need to do is create a dynamic constant buffer resource with the appropriate size (sizeof(LightConstantBuffer), rounded up to the next multiple of 16 bytes) during initialization, then each frame you can Map it to fill it with the current lights + number of lights for each draw call. To fill it you can just cast the void pointer you get back from Map to the type LightConstantBuffer*, and then you can just set all of the values. And don't forget to bind the constant buffer to the pixel shader stage as well.

It works that way for structures declared in constant buffers, yes. For variables that aren't structures the packing rules are a bit more complex. See this for more info.