#include 
using namespace std;
void merge(int A[],int B[],int C[],int a,int b)
{
    int i,j,k;
    i=j=k=0;
    while(i& counts,int& readSize,char *buffer)
{
    for (int i=0;i 1 ) {
        node *child0 = new node( q.top() );
        q.pop();
        node *child1 = new node( q.top() );
        q.pop();
        q.push( node( child0, child1 ) );
        }
}
//_____________________________________makeTree_________________________________

void makeTree(const vector counts ,
 priority_queue< node,vector,greater > & q)
{
    node tmpNode;
    for ( int i = 0 ; i < SIZE ; i++ )
        if ( counts[ i ] )
        {
            assert(i != 300);
            tmpNode=node( i, counts[ i ] );
            q.push( tmpNode );
            charWeight.push_back(make_pair(tmpNode.value,tmpNode.weight));
        }

    q.push(node (CTRLCHAR,0));

//making huffman tree

    while ( q.size() > 1 ) {
        node *child0 = new node( q.top() );
        q.pop();
        node *child1 = new node( q.top() );
        q.pop();
        q.push( node( child0, child1 ) );
        }
}

//____________________________________toChar___________________________________
    unsigned char toChar(string tmp)
    {
        //static ofstream fout("outcheck");
        int sum=0,count=0;
        for(int i=tmp.size()-1 ; i >=0 ;--i,++count)
            sum+=(tmp[i]-'0')*pow(2.0,count);
        //fout< (sum);
    }

//___________________________________writeBit___________________________________
    void writeBit(char bit,bool nextReadFlag,string & endSt,ostream & fout)
    {
        static string asciiBuf="";
        static int count=0;
        unsigned char ch;

        asciiBuf+=bit;
        count++;
        if(count==8)
        {
            ch=toChar(asciiBuf);
            fout<& stArray,string format)
{
    
    bool nextReadFlag=true;
    fout.seekp(0);
    fout< >::iterator i=charWeight.begin();ifirst != CTRLCHAR)
            fout<<" "<first<<" "<second;

    string endSt=stArray[CTRLCHAR];
    fout<<" "<result.begin() ;)
        {
            i--;
            j--;
            *i=*j;
        }
        memory[x]=lastResult;
    }
    return memory[x];
}
//____________________________________makeBinary_________________________________
void makeBinary(char * buffer,int size,vector & codes)
{
    int ascii;
    for(int i=0 ; i codes;
    const node * root=&q.top();
    static const node * curPos=root;
    
    makeBinary(buffer,size,codes);

    for(vector::iterator i=codes.begin(); ibegin(); j < i->end() ; ++j)
    {
        if(curPos->value==300) return;
        if(*j=='0')
        {
            ctrl+='0';
            curPos=curPos->child0;
        }else
            if(*j=='1')
            {
                ctrl+='1';
                curPos=curPos->child1;
            }

        if(!curPos->child0)
        {
            if(curPos->value !=300)
            {
                fout<<(unsigned char)curPos->value;
                curPos=root;
                ctrl="";
            }
    
        }
    }
}
//__________________________makeOutputName________________________________________​

string makeOutputName(string file,string &format)
{
    bool check=false;
    string result="";
    string::iterator it=file.begin();
    while(*it != '.')
    {
        if(it == file.end()-1)
            break;
        
        result+=*it;
        it++;
        if(*it=='.')
            check=true;
    }
    if(check)
    {
        result+=".rrm";
        it++;
        for(;it counts(SIZE,0);
    bool repeat=true;
    char * filenametmp=new char[100];
    string filename;
    string output,format="";
    
    cout<<"enter file name:";
    cin>>filenametmp;
    filename=filenametmp;
    output=makeOutputName(filename,format);

    ifstream fin(filename.data(),ios::binary);
    if ( !fin ) {
        cerr << "Couldn't open the input file!\n";
        system("pause");
        throw "abort";
    }

    while(repeat)
    {
        repeat=bufferRead(fin,readSize,buffer);
        count_chars( counts, readSize,buffer);
    }

    priority_queue< node,vector, greater > q;
    makeTree(counts,q);

    delete[] buffer;
    buffer=NULL;
    counts.clear();
    ofstream fout(output.data(),ios::binary);


    vector stArray(SIZE,"");
    q.top().traverse(stArray,fout);


    makeCodedFile(fout,fin,stArray,format);
    fin.close();
    fout.close();

  return;
}
//____________________________________decompress__________________________________​_
void decompress()
{
    unsigned char temp;//testing purpose
    bool repeat=true;
    unsigned char chTemp;
    int weight;
    char formatTmp[10];
    char endCtrlTmp[100];    
    char fileNameTmp[100];
    const int size=sizeof(char)*1024*1024;
    int readSize=size;
    int dicSize;
    char* buffer=new char [size];
    string format,fileName,output="";
    
    cout<<"Enter the rrm file name:";
    cin>>fileNameTmp;
    fileName=fileNameTmp;

    ifstream fin(fileName.data(),ios::binary);
    //ofstream fout("extracted.txt",ios::binary);

    if ( !fin ) {
        cerr << "Couldn't open the input file!\n";
        system("pause");
        throw "abort";
    }

    
    long int s=getFileSize(fin,0);
    fin.close();
    fin.open(fileName.data(),ios::binary);
    
    fin>>dicSize;

    while(dicSize--)
    {
        fin.read((char *)&chTemp,1);
        fin.read((char *)&chTemp,1);
        fin>>weight;
        q.push(node(chTemp,weight));
    }
    q.push(node(300,0));

    fin>>endCtrlTmp;
    endCtrl=endCtrlTmp;
    fin.read((char *)&chTemp,1);

    fin>>formatTmp;
    format=formatTmp;
    fin.read((char *)&chTemp,1);
    
    output=makeOutforDec(fileName,format);

    ofstream fout(output.data(),ios::binary);
    
    makeTree(q);
    streamoff i=fin.tellg();

    repeat=bufferRead(fin,readSize,buffer,i,true);
    encode(buffer,readSize,fout);

    while(repeat)
    {
        repeat=bufferRead(fin,readSize,buffer,i,false);
        encode(buffer,readSize,fout);
    }

    //assert (s==fin.tellg());
    fin.close();
    fout.close();

    return;
}
//_____________________________________main_______________________________________​_________
int main()
{
    bool check=true;
    char ch;
    while (check)
    {
        cout<<"Do you want to compress or decompress?(C/D)"<>ch;
        if(ch=='D'|| ch=='d')
        {
            decompress();
            check=false;
        }
        else
        if(ch=='C' || ch=='c')
        {
            compress();
            check=false;
        }
    }
    system("pause");
    return 0;
}

//Q-Learning
#include
#include
#include
using namespace std;

const int SIZE=6;
//*********************
struct node
{
       int destination;
       int s;
       float distance;
       string p;
};
//*********************
int max_distance(node []);
void dijkstra ( int ,int, float [][6] );
//*********************

class Q_Learning
{
       public:
              Q_Learning(int,int);
              void displayR();
              void displayQ();
              void routing();
       private:
               float Q_cal(int,int);
               float find_max(int);
               float Q[6][6];
               float R[6][6];
               int start_state;
               int goal_state;
               float Y;
               // state shoroo ham bayad bashe baadan
};
//*********************
Q_Learning :: Q_Learning(int s , int g)
{
           int i,j,k,l,state,action;
           float temp;
           vector states;
           Y=0.8;
           start_state=s;
           goal_state=g;
           for ( i=0 ; i states;
      for (i=0 ; i::min(); // MIN_FLOAT
         }
     dijkstra ( start_state ,goal_state,  temp );
}
//*********************

void Q_Learning :: displayR()//namayeshe maghadire R
{
     int i,j;
     char item[6]={'A','B','C','D','E','F'};
     system("cls");
     cout<<"\n -1 --> No way\n 0 --> Is way\n 100 --> Direct way\n";
     cout<<"\nRoads matrix = :\n\n  ";
     for (i=0 ; i<6 ; i++)
         cout<::min();
    for (i=0 ; i max && a[i].s == 0)
        {
           max = a[i].distance;
           max_index = i;
        }
    }
    return max_index;
}
//*********************
void dijkstra ( int v ,int g, float P[6][6] )
{
     int u,i,j,k;
     float NP[6][6];
     char ch[6]={'A','B','C','D','E','F'};
     node state[6];
     
     for (i=0 ; i< SIZE ; i++)
         for (j=0 ; j< SIZE ; j++)
         {
             NP[i][j]=P[i][j];
             if (NP[i][j] == 0 && i!=j)
                NP[i][j]=std::numeric_limits::min(); // MIN_FLOAT
         }
     
     for (i=0 ; i< SIZE ; i++)
     {
         state[i].destination=i;
         state[i].s=0;
         state[i].distance=NP[v][i];
         state[i].p = v+'0';
     }
     state[v].s=1;
     
     
     for (j=1 ; j< SIZE ; j++)
     {
         u=max_distance(state);
         state[u].s=1;
         state[u].p += u+'0';
         
         for (k=0 ; k< SIZE ; k++)
             if (state[k].s == 0)
             {
                if ( NP[u][k] != std::numeric_limits::min() )
                   if ( state[k].distance < state[u].distance + NP[u][k] )
                   {
                        state[k].distance = state[u].distance + NP[u][k];
                        state[k].p = state[u].p;
                   }
             }
             
     }
     /*for (i=0 ;i< SIZE ; i++)
     {
         cout<<"From "<
 Collapse Copy Code
class MyInt {
private:
	int i;
public:
	MyInt(int iVal) { i = iVal; };
	int val() const { return i; };
	MyInt(const MyInt& t) { i = t.val(); };

	MyInt& operator=(const MyInt& t) {
		i = t.val();
		return *this;
	};

	MyInt operator++(int) {
		MyInt t = *this;
		i++;
		return t;
	};
};

MyInt func() {
	MyInt i = MyInt(1);
	i = i++;
	return i;
}

int _tmain(int argc, _TCHAR* argv[])
{
	int i = 1;
	i = i++;
	_tprintf(_T("%d\n"), i);

	MyInt t = func();
	_tprintf(_T("%d\n"), t.val());
	return 0;
}
 Collapse Copy Code
Result is
2
1
But it is exactly what Java/.NET returns. From this, it is logical to conclude that Java/.NET primitives are boxed (which seems to be logical, otherwise it is hard to imagine how to support platform independence in Java/.NET, for example replacing the above class with a structure like "struct MyInt { int i : 32; };" in order to support 32 bits integers). Also this means that C/C++ works faster with primitives :)
CodeProject 

 
 
از آدرس:
http://www.codeproject.com/Articles/67392/Re-boxed-primitives-in-Java-and-NET.aspx