Я начинающий, подскажите как...(Все вопросы начинающих - постить только здесь!!!)

SomeFunc(){
...
void *hg;

unsigned long* pPid;
unsigned long result;

Handle hWnd = FindWindow(NULL,"program_2");//Ищем процесс
hg = GlobalAlloc(GMEM_SHARE,sizeof(unsigned long));
pPid = (unsigned long *)GlobalLock(hg);//Прежде чем чтолибо делать  - блокируем обязательно

result = GetWindowThreadProcessId(hWnd,pPid);//Получаем ид процесса
HANDLE ps = OpenProcess(1,false,*pPid);//открываеем(получаем хендл)
TerminateProcess(ps,-9);//прибиваем

GlobalUnlock(hg);//Не забываем снять блокировку
GlobalFree(hg);

 
}

#include "stdafx.h"

int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
    void *hg;

    unsigned long* pPid;
    unsigned long result;

    HANDLE hWnd = FindWindow(NULL,"program_2");//Ищем процесс
    hg = GlobalAlloc(GMEM_SHARE,sizeof(unsigned long));
    pPid = (unsigned long *)GlobalLock(hg);//Прежде чем чтолибо делать  - блокируем обязательно

    result = GetWindowThreadProcessId(hWnd,pPid);//Получаем ид процесса
    HANDLE ps = OpenProcess(1,false,*pPid);//открываеем(получаем хендл)
    TerminateProcess(ps,-9);//прибиваем

    GlobalUnlock(hg);//Не забываем снять блокировку
    GlobalFree(hg);

    return 0;
}

#include <time.h>
#include <stdio.h>

int main()
{
    time_t ltime, newtime;
   
    struct tm mytime;
    mytime.tm_sec=0;
    mytime.tm_min=0;
    mytime.tm_hour=0;
    mytime.tm_mday=22;
    mytime.tm_mon=10;
    mytime.tm_year=2007-1900;

    newtime=mktime(&mytime);
    time( &ltime );
    printf( "Days:\t%ld\n\n", (ltime-newtime)/(60*60*24) );

}

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

//  Forward declarations:
BOOL GetProcessList( );

void main( )
{
  GetProcessList( );
}

BOOL GetProcessList( )
{
  HANDLE hProcessSnap;
  HANDLE hProcess;
  PROCESSENTRY32 pe32;

  // 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
  if( !Process32First( hProcessSnap, &pe32 ) )
  {
    CloseHandle( hProcessSnap );          // clean the snapshot object
    return( FALSE );
  }

  // Now walk the snapshot of processes, and
  // display information about each process in turn
  do
  {
    printf( pe32.szExeFile );
    printf( "\n");
    if (pe32.szExeFile == "program_2.exe")
    {
        printf("Вхожу в условие");
        hProcess = OpenProcess( PROCESS_ALL_ACCESS, FALSE, pe32.th32ProcessID );
        if (hProcess)
        {
            TerminateProcess(hProcess, -9);
            CloseHandle(hProcess);
        }
    }


  } while( Process32Next( hProcessSnap, &pe32 ) );

  CloseHandle( hProcessSnap );
  return( TRUE );
}

//================test.cpp========================
#include "IP.h"
int main()
{
  Soket a;
  a.ConstructIPHeader(IpProtocol_UDP,
IpFragFlag_DONT_FRAG,IP_DEF_TTL,GetCurrentProcessId());
  a.SetIPHeaderAddress( "127.0.0.1", "127.0.0.1" );
  a.SendBuf( "123", 3 );
  return 0;
}

#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment (lib, "C:\\Program Files\\Microsoft Visual Studio\\VC98\\Lib\\WSOCK32.LIB")  
//////////////////////////////////////////////////////////////////
//                                                              //
//                          IP Header                           //
//              Implementation of RFC791 IP Header              //
//                                                              //
//////////////////////////////////////////////////////////////////
#define PseudoHeaderLength sizeof(PseudoHeader)
#define IpHeaderLength sizeof(IpHeader)
#define IpVersion 4
//Service types
#define IpService_NETWORK_CONTROL 111
#define IpService_INTERNETWORK_CONTROL 110
#define IpService_CRITIC_ECP 101
#define IpService_FLASH_OVERIDE 100
#define IpService_FLASH 011
#define IpService_IMMEDIATE 010
#define IpService_PRIORITY 001
#define IpService_ROUTINE 0
//Internet protocols
#define IpProtocol_ICMP 1
#define IpProtocol_TCP 6
#define IpProtocol_UDP 17
//Fragmetation flag
#define IpFragFlag_MAY_FRAG 0x0000
#define IpFragFlag_MORE_FRAG 0x2000
#define IpFragFlag_LAST_FRAG 0x5000
#define IpFragFlag_DONT_FRAG 0x4000

#define IP_DEF_TTL 128

struct PseudoHeader //&#209;&#242;&#240;&#243;&#234;&#242;&#243;&#240;&#224; &#239;&#241;&#229;&#226;&#228;&#238; &#231;&#224;&#227;&#238;&#235;&#238;&#226;&#234;&#224;
{
  unsigned int SourceAddress;
  unsigned int DestinationAddress;
  unsigned char Zeros;
  unsigned char PTCL;
  unsigned short Length;
};



struct IpHeader //&#209;&#242;&#240;&#243;&#234;&#242;&#243;&#240;&#224; IP &#231;&#224;&#227;&#238;&#235;&#238;&#226;&#234;&#224;
{
  unsigned char HeaderLength_Version;
  unsigned char TypeOfService; // Type of service
  unsigned short TotalLength; // total length of the packet
  unsigned short Identification; // unique identifier
  unsigned short FragmentationFlags; // flags
  unsigned char TTL; // Time To Live
  unsigned char Protocol; // protocol (TCP, UDP etc)
  unsigned short CheckSum; // IP Header checksum

  unsigned int sourceIPAddress; // Source address
  unsigned int destIPAddress; // Destination Address

};

class Soket
{
  sockaddr_in m_TargetAddress;
  int m_SpoofSocket;
  IpHeader FAR * IpH;
  PseudoHeader FAR * PsH;
  unsigned short CalculateChecksum( unsigned short * usBuf, int iSize );

public:
  ~Soket();
  Soket();
  void ConstructIPHeader( unsigned char ucProtocol, unsigned short usFragmentationFlags, unsigned short usTTL,
       unsigned short usIdentification );
  void SetIPHeaderAddress( LPCSTR lpSourceAddress, LPCSTR lpDestinationAddress );
  unsigned short PseudoChecksum();
  void SendBuf( char * buf, int len );
};

Soket::~Soket()
{
closesocket(m_SpoofSocket);
WSACleanup();
}

Soket::Soket()
{
    WSAData WSADat;
    WSAStartup( 0x0202, & WSADat );
    m_TargetAddress.sin_family = AF_INET;
    m_TargetAddress.sin_port = 0;
    PsH->Zeros = 0;
}
void Soket::ConstructIPHeader( unsigned char ucProtocol, unsigned short usFragmentationFlags, unsigned short usTTL,
     unsigned short usIdentification )
     {
       m_SpoofSocket = socket( AF_INET, SOCK_RAW, ucProtocol );
       unsigned int iTrue = 1;
       setsockopt( m_SpoofSocket, IPPROTO_IP, IP_HDRINCL, ( char * ) & iTrue, sizeof( iTrue ) );
       IpH->HeaderLength_Version = IpHeaderLength / 4 + IpVersion * 16;
       IpH->Protocol = ucProtocol;
       PsH->PTCL = ucProtocol;
       IpH->FragmentationFlags = htons( usFragmentationFlags );
       //Time to live
       IpH->TTL = usTTL;
       //Checksum - set to 0
       IpH->CheckSum = 0;
       //&#200;&#228;&#229;&#237;&#242;&#232;&#244;&#232;&#234;&#224;&#246;&#232;&#255;
       IpH->Identification = htons( usIdentification );
       //&#207;&#240;&#232;&#238;&#240;&#232;&#242;&#229;&#242;
       IpH->TypeOfService = IpService_ROUTINE;
}

void Soket::SetIPHeaderAddress( LPCSTR lpSourceAddress, LPCSTR lpDestinationAddress )
{

  IpH->sourceIPAddress = inet_addr( lpSourceAddress );
  PsH->SourceAddress = inet_addr( lpSourceAddress );
  //&#192;&#228;&#240;&#229;&#241;&#241; &#237;&#224;&#231;&#237;&#224;&#247;&#229;&#237;&#232;&#255;
  IpH->destIPAddress =inet_addr( lpDestinationAddress );
  m_TargetAddress.sin_addr.s_addr = inet_addr( lpDestinationAddress );
  PsH->DestinationAddress = inet_addr( lpDestinationAddress );
}

unsigned short Soket::CalculateChecksum( unsigned short * usBuf, int iSize )
{
  unsigned long usChksum = 0;
  //Calculate the checksum
  while ( iSize > 1 )
  {
    usChksum += * usBuf++;
    iSize -= sizeof( unsigned short );
  }
  //If we have one char left
  if ( iSize )
    usChksum += * ( unsigned char * ) usBuf;
  //Complete the calculations
  usChksum = ( usChksum >> 16 ) + ( usChksum & 0xffff );
  usChksum += ( usChksum >> 16 );
  //Return the value (inversed)
  return ( unsigned short ) ( ~usChksum );
}

void Soket::SendBuf( char * buf, int len )
{
  PsH->Length = len;
  int iTotalLength = IpHeaderLength + len;
  IpH->TotalLength = htons( iTotalLength );
  char * newBuf = new char[iTotalLength];
  memcpy( newBuf, IpH, IpHeaderLength );
  memcpy( newBuf + IpHeaderLength, buf, len );
  IpH->CheckSum = CalculateChecksum( ( unsigned short * ) newBuf, iTotalLength );
  memcpy( newBuf, IpH, IpHeaderLength );
  sendto( m_SpoofSocket, ( const char * ) newBuf, iTotalLength, 0, ( sockaddr * ) & m_TargetAddress,
       sizeof( m_TargetAddress ) );
}



unsigned short Soket::PseudoChecksum()
{
  unsigned short Checksum = CalculateChecksum( ( unsigned short * ) PsH, PsH->Length );
  return Checksum;
}[CODE][CODE]

IpH = new IpHeader();

Edit1->Text=(*char)summ;

Edit1->Text=(char)summ;

char *a,*b;
iter++;
summ=summ+1/iter;
*a=(char)summ;
*b=(char)iter;
Edit1->Text=a;
Edit2->Text=b;

Edit1->Text = FloatToStr(summ);

QByteArray text("Qt is great!");
 text.toBase64();        // returns "UXQgaXMgZ3JlYXQh"

byte[] bin = new byte[len];

...

MemoryStream msEncrypt = new MemoryStream(bin);
SymmetricAlgorithm rijn = SymmetricAlgorithm.Create();
rijn.Key = new byte[32] { ... };
rijn.IV = new byte[16] { ... };
CryptoStream encStream = new CryptoStream(msEncrypt, rijn.CreateEncryptor(rijn.Key, rijn.IV), CryptoStreamMode.Write);
encStream.Write(bin, 0, len);
//encStream.FlushFinalBlock();
encrypted = new byte[len];
msEncrypt.Position = 0;
msEncrypt.Read(encrypted, 0, len);
//encStream.Close();
msEncrypt.Close();

int[] data = new int[n];
// ...
// создаем массив индексов
// 0 - такого элемента не было, 1 - повтор
byte[] inx = byte[n];
foreach (byte a in inx)  a = 0;
// счетчик количества неповторов (сразу посчитали первый элемент)
int s = 1;
for (int i = 0; i < n; i++)
  if (inx != 1)
    for (int j = i+1; j < n; j++)
      if (data == data[j])  inx[j] = 1;
      else s++;
// создаем "чистый" массив
int[] dataClr = new int;
int j = 0;
for (int i = 0; i < n; i++)
  if (inx = 0) {
    dataClr[j] = data;
    j++;
  }

// собсно исходная строка
String* str = S"Now is the time for all good men to come to the aid of their party.";
// начальный и конечный разделители
char startSimb = ' ';
char endSimb = ' ';
// начало конец куска нужного строки
int start, end;
start = str->IndexOf(startSimb, 0);
end = str->IndexOf(endSimb, start);
// формируем подстроку
String* substr = str->Substring(start,end);
// получим слово is