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

#include <string>
#include <fstream>
#include <iostream>
using namespace std;

int main()
{
    ifstream in( "in.txt" );
    if (!in.is_open())
    return -1;

    while (!in.eof())
    {
    string bignum;
    in >> bignum;

    string::size_type indexDot = bignum.find( '.' );
    if ( string::npos == indexDot )
        continue;

    string mainpart = bignum.substr( 0, indexDot++ );
    string mantissa = bignum.substr( indexDot );

    cout << mainpart << '.' << mantissa << endl;

    // тут преобразовывай и выкидывай в какой-нить контейнер
    }

    in.close();

    // тут сохраняй из контейнера

    return 0;  
}

#include <string>
#include <vector>
#include <fstream>
#include <iostream>
using namespace std;

int main()
{
    ifstream in( "in.txt" );
    if (!in.is_open())
    return -1;

    typedef vector< pair<string, string> > BinArray;
    BinArray myArray;

    while (!in.eof())
    {
    string n;
    in >> n;

    string::size_type indexDot = n.find( '.' );
    if ( string::npos == indexDot )
        continue;

    string m1 = n.substr( 0, indexDot++ );
    string m2 = n.substr( indexDot ));
    myArray.push_back( make_pair(m1, m2) );
    }

    in.close();

    // --- Для просмотра контейнера ---
    typedef BinArray::const_iterator ba_cIter;
    for (ba_cIter it = myArray.begin(); it != myArray.end(); it++)
    cout << it->first << '.' << it->second << endl;

    return 0;  
}

...
   binary num;
    num.indMPRT=0;
    num.indMNTS=0;
    //(ниже) вызываем ф-ю считывания из файла числа
    binary::in_num(num.mainpart, num.indMPRT, num.mantissa, num.indMNTS);
...

//(ниже) вызываем ф-ю вывода на экран числа
    binary::out_num(num.mainpart, num.indMPRT, num.mantissa, num.indMNTS);

// (ниже) идёт проверка на точку
        if ((c==48) || (c==49) || (c==50) || (c==51)
         || (c==52) || (c==53) || (c==54) || (c==55)
         || (c==56) || (c==57)) i++;
        else break;

...
    for (int k=0; k<=i; k++)
    {
        a1[k]=c[k];  // неявное преобразование
        a1[k]=(a1[k]-48);
    };

void out_num (int ar1[], int z1, int ar2[], int z2)
{
     for (int g1=0; g1<=z1; g1++)
     {
         cout<<ar1[g1];
     };
     for (int g2=0; g2<=z1; g2++)
     {
         cout<<"."<<ar2[g2];
     }
// вывели значение ввиде:
// [элементы первого массива без пропусков].[элементы второго массива без пропусков]
     cout<<endl;
     system("pause");
     exit(0);
}

binary::in_num();

num.in_num();

//---------------------------------------------------------------------------
#include <stdio.h>
#include <conio.h>
#define N 4
//---------------------------------------------------------------------------

int main()
{
int mas[N][N] = {8, 5, 7, 4,
                 4, 0, 4, 1,
                 9, 4, 7, 4,
                 3, 2, 9, 8};
int sum[N], num[N] = {1, 2, 3, 4};
int i, j, k, min, temp;

    for(i = 0; i < N; i++) {
        printf("%d\t", num);
        for(j = 0; j < N; j++) printf("%4d", mas[j]);
        printf("\n");
    }
    printf("\n\n");

    for(i = 0; i < N; i++) {
        sum = 0;
        for(j = 0; j < N; j++)
            sum += mas[j];
    }

    for(i = 0; i < (N - 1); i++) {
        min = i;
        for(j = i + 1; j < N; j++) {
            if(sum[j] < sum[min]) min = j;
        }
        temp = sum;
        sum = sum[min];
        sum[min] = temp;

        for(k = 0; k < N; k++) {
            temp = mas[k];
            mas[k] = mas[min][k];
            mas[min][k] = temp;
        }
        temp = num;
        num = num[min];
        num[min] = temp;
    }

    for(i = 0; i < N; i++) {
        printf("%d\t", num);
        for(j = 0; j < N; j++) printf("%4d", mas[j]);
        printf("\n");
    }

    getch();

    return 0;
}
//---------------------------------------------------------------------------

#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>
using namespace std;
typedef struct
       {
        char fam [40];
        char nam [40];
        char otch [40];
        char dol [40];
        char date [10];
        float zp;
        }EMPLOYEE;
EMPLOYEE cadd(int n)
{  EMPLOYEE mass[n];
  //формируем запись sotr
   for(int i=0;i<=n;i++)
  { cout<<"fam="; cin>> mass.fam;
   cout<<"nam="; cin>> mass.nam;
   cout<<"otch="; cin>> mass.otch;
   cout<<"dol="; cin>> mass.dol;
   cout<<"date="; cin>> mass.date;
   cout<<"zp="; cin>> mass.zp;
   }
   return mass[n];
}
int main()
{ FILE *fp;

  int n=0;
  cin>>n;
  EMPLOYEE sotr[]=cadd(10);

  fp = fopen("file.txt","wb");
   if (fp==NULL)
                {
                 cout<<"Error opening file: "<<ferror(fp)<<'\n';
                 return 1;
                }
   fwrite(&sotr, sizeof(EMPLOYEE),1,fp);
   fclose(fp);

      system("PAUSE");
      return 0;
}

EMPLOYEE sotr[]=cadd(10);

EMPLOYEE *sotr = new EMPLOYEE[n];

EMPLOYEE cadd()
{
    EMPLOYEE empl;

    cout<<"fam=";   cin>> empl.fam;
    cout<<"nam=";   cin>> empl.nam;
    cout<<"otch=";  cin>> empl.otch;
    cout<<"dol=";   cin>> empl.dol;
    cout<<"date=";  cin>> empl.date;
    cout<<"zp=";    cin>> empl.zp;

    return empl;
}

for(int i = 0; i < n; i ++)
      sotr = cadd();

#include <cstdio>
#include <fstream>
#include <cstdlib>
#include <binary.h>

using namespace std;

int main()
{
    binary num;
    num.in_num();
    num.num_mainpart_conv();
    num.num_mantissa_conv();
    return 0;
}

// binary.h
#include <cstdio>
#include <fstream>
#include <cstdlib>
#include <iostream>

using namespace std;

class binary
{
      public:
// поскольку по условию работа будет с большими числами,
// то размер массивов целой и дробной части числа
// сделаем по 505 символов
// всего число сможет иметь максимально от 505 до 1010 цифр
// думаю должно хватить =)
             int mainpart[505];
             int convertedMPRT[2000];
             int INDconvertedMPRT;
             int mantissa[505];
             int convertedMNTS[2000];// тут сохраняется уже двоичный код дробной части
             int INDconvertedMNTS;// индекс последнего эл.
      //(ниже) индекс последнего элемента mainpart
             int indMPRT;
      // (ниже) индекс последнего элемента mantissa            
             int indMNTS;
             void in_num(); // ф-я считывания. записывает целую и дробную части числа в 2 массива:
                                    // mainpart и mantissa
             void divide_num(); // деление массива целой части числа на 2
             void num_mainpart_conv(); //ф-я перевода целой части, использует divide_num
             void mult_num(); // умножение массива целой части числа на 2.
                                         // сделано так, что только первый элемент может иметь две цифры
                                         // 1 цифра(десятки) это кагбэ если при умножении дроби 0.712 на 2 = 1.424
                                         // то нулевой элемент был бы 14 массива
                                         // первый соответственно 2 и т.д.
             void num_mantissa_conv(); //ф-я перевода дробной части числа записанного в массив
                                                         //использует ф-ю mult_num
};

void binary::in_num()
{
    ifstream in;
    in.open("in.txt");
    char c[510];
    int i=0;
    while (in)
    {
        in>>c;
    // (ниже) идёт проверка на не цифру (подразумевается что будет точка)
        if ((c==48) || (c==49) || (c==50) || (c==51)
         || (c==52) || (c==53) || (c==54) || (c==55)
         || (c==56) || (c==57)) i++;
        else break;
    };
    i--;
    indMPRT=i;
    for (int k=0; k<=i; k++)
    {
        mainpart[k]=c[k];
        mainpart[k]=(mainpart[k]-48);
    };
    int j=0;
    while (in)
    {
        in>>c[j];
        j++;
    };
    j=j--;
    indMNTS=j;
    for (int k=0; k<=j; k++)
    {
        mantissa[k]=c[k];
        mantissa[k]=(mantissa[k]-48);
    };
    in.close();
    return;
}


void binary::divide_num()
{
    int state=0;
    int ii=0;
    int del[505];
    int d=0;
    int p;
    convertedMPRT[INDconvertedMPRT]=mainpart[indMPRT]%2;
    while(ii<=indMPRT)
    {
        if ((mainpart[ii]==0) && (state==0))
        {
            del[d]=0;
            d++;
        }
        else
        {
            if ((mainpart[ii]==1) && (state==0) && (ii!=0))
            {
                state=1;
                del[d]=0;
                d++;
            }
            else
            {
                if ((mainpart[ii]==1) && (state==0) && (ii==0))
                {
                    state=1;
                }
                else
                {
                    if ((mainpart[ii]!=0) && (mainpart[ii]!=1) && (state==0))
                    {
                       p=mainpart[ii];
                       del[d]=p/2;
                       d++;
                       state=p%2;
                    }
                    else
                    {
                        if (state==1)
                        p=10+mainpart[ii];
                        del[d]=p/2;
                        d++;
                        state=p%2;
                    }
                }
            }
        };
    ii++;
    };
    ii--;
    d--;
    int hh;
    for(hh=0; hh<d; hh++)
    {
        mainpart[hh]=del[hh];
    };
    indMPRT=hh;
    return;
}

void binary::num_mainpart_conv()
{
    INDconvertedMPRT=1;
    while((indMPRT!=0) && (mainpart[0]>=2))
    {
        binary::divide_num();
        INDconvertedMPRT++;
    };
    INDconvertedMPRT--;
    convertedMPRT[0]=mainpart[0];
    ofstream out;
    out.open("out.txt");
    cout<<endl;
    for (int z=0; z<=INDconvertedMPRT; z++)
    {
        cout<<convertedMPRT[z];
    };
    out.close();
    return;
}

void binary::mult_num()
{
    int yy=0;
    for(yy=0; yy<=indMNTS; yy++)
    {
        mantissa[yy]=mantissa[yy]+mantissa[yy];
    };
    for(int yyy=indMNTS; yyy>=1; yyy--)
    {
        if (mantissa[yyy]>9)
        {
            mantissa[(yyy-1)]=mantissa[yyy]/10;
            mantissa[yyy]=mantissa[yyy]%10;
        };
    };
    yy--;
    while (mantissa[yy]==0)
    {
        indMNTS--;
        yy--;
    };
}

void binary::num_mantissa_conv()
{
    int r=0;
    ofstream out;
    out.open("out.txt");
    cout<<".";
    int period[505][400];
    for(int l=0; l<indMNTS; l++)
    {
         period[0][l]=mantissa[l];
    };
    int e1=0;
    while(true)
    {
        binary::mult_num();
        convertedMNTS[r]=mantissa[0]/10;
        mantissa[0]=mantissa[0]%10;
        for(int uu=0; uu<=e1; uu++)
        {
            for(int uuu=0; uuu<indMNTS; uuu++)
            {
                if (period[uu][uuu]==mantissa[indMNTS])
                {
                    for(int q=0; q<uu; q++)
                    {
                        cout<<convertedMNTS[uu];
                    };
                    cout<<"(";
                    for(int qq=uuu; qq<=indMNTS; qq++)
                    {
                        cout<<convertedMNTS[qq];
                    };
                    cout<<")"<<endl;
                    out.close();
                    cout<<endl;
                    system("pause");
                    exit(0);
                };
            };
        };
        for(int gg=0; gg<=indMNTS; gg++)
        {
            if (mantissa[gg]!=0) break;
            if (gg==indMNTS)
            {
                for(int hhh=0; hhh<r; hhh++)
                {
                    cout<<convertedMNTS[hhh];
                };
                out.close();
                cout<<endl;
                system("pause");
                exit(0);
            };
        };
        if (r==400)
        {
            for(int bb=0; bb<=r; bb++)
            {
                cout<<convertedMNTS[bb];
            };
            cout<<endl;
            system("pause");
            exit(0);
        };
        r++;
    };
}

DWORD dwStyle = GetWindowLong(hWnd, GWL_EXSTYLE);
SetWindowLong(hWnd, GWL_EXSTYLE, dwStyle | WS_EX_ACCEPTFILES);

char tmp[256];
 case WM_DROPFILES:
  HDROP hDrop = (HDROP)wParam;
  DWORD DropsNo = DragQueryFile(hDrop, -1, NULL, 0);

  for (DWORD i = 0; i < DropsNo; i++)
  {
   DragQueryFile(hDrop, i, tmp, 256);
   MessageBox(NULL, tmp, "", MB_OK); // Что ни будь делаем с данными...
  }
  DragFinish(hDrop);
 return(0);

#include <stdio.h>
#include <conio.h>
#include <string.h>
#include <fstream.h>
const n=3;
struct student
{
 char fio[20];
 char pol[3];
 int stp[30];
};
student gr[n];
 int i;
int main()
{
 ifstream input("input.txt");
 ofstream output("output.txt");
   for(i=0;i<n;i++)
   input>>gr.fio>>gr.pol>>gr.stp;
   output<<("Девушки получающие повышенную стипендию:\n");
     for(i=0;i<n;i++)
     if ((gr.stp > 1100) && (!strcmp(gr.pol,"z")))
     output<<gr.fio<<"\n";
input.close();
output.close();
getch();
return 0;
}

#include <iostream>
#include <fstream>
#include <string>
#include <WinSock2.h>
#pragma comment(lib,"Ws2_32.lib")

using namespace std;


int main()
{
    WORD wVersionRequested;
    WSADATA wsaData;
    wVersionRequested = MAKEWORD(2, 2);
    int s=socket(AF_INET,SOCK_STREAM,0);
    SOCKADDR_IN sin;
    sin.sin_family=AF_INET;
    sin.sin_port=htons(3456);
    WSAStartup(wVersionRequested, &wsaData);
    PHOSTENT phe=gethostbyname("localhost");
    memcpy((char FAR *)&(sin.sin_addr ),
        phe->h_addr_list , phe->h_length);
    int con=connect(s,(struct sockaddr *)&sin,sizeof(&sin));
    cout<<con<<endl;
    cout<<WSAGetLastError()<<endl;
    WSACleanup();
   
       
}

#include<conio.h>
#include<iostream>     
int main(int argc, char* argv[])
{
    cout << "Enter the string: ";
    char* string = new char [];
    cin >> string;
    int c=0;
    while(*string != '\0')
    {
        if (*string == '1'){c++;}
        string++;
    }
    cout<<'\n'<<c;
        getchar();
}

char* string = new char [];

...
    int s=socket(AF_INET,SOCK_STREAM,0);
...
    WSAStartup(wVersionRequested, &wsaData);
...

inline dVector& dMatrix::operator[] (int  i)
{
    return (&m_front);
}

inline const dVector& dMatrix::operator[] (int  i) const
{
    return (&m_front);
}