C / C++ / MFC

 mi.cbSize = sizeof(mi);
GetMonitorInfo(hMonitor, &mi);

mix.cbSize = sizeof(mix);
GetMonitorInfo(hMonitor, (MONITORINFO*)&mix);
CString display;
display.Format("%s" ,(LPSTR)mix.szDevice);
		
if(strcmp(display,\\.\DISPLAY1)==0)    //PROBLEM IS HERE
{
	DualRect = mi.rcMonitor;	
	display.Format(" Res[%d,%d,%d,%d]",DualRect.left,DualRect.right,DualRect.top,DualRect.bottom);
	AfxMessageBox(display);
}

//ect/countprt.hpp

#ifndef COUNTED_PTR_HPP
#define COUNTED_PTR_HPP

/*class template for smart pointer with reference semantics
 *	-destroys the object that is referred to when the last CountedPTr that refers to it is destroyed
 */
template <typename T>
class CountedPtr
{
private:
	T* ptr;				//pointer to the actual object
	long* count;		//reference to the number of pointers that refer to it

public:
	//initialize with ordinary pointer
	//	-p has to be a value returned by new
	explicit CountedPtr(T* p = 0) : ptr(p), count(new long(1))
	{

	}

	//copy constructor
	CountedPtr(const CountedPtr<T>& p) throw() : ptr(p.ptr), count(p.count)		//copy object and counter
	{
		++count;																//increment number of references
	}

	//destructor
	~CountedPtr() throw()
	{
		release();		//release reference to the object
	}

	//assignment
	CountedPtr<T>& operator= (const CounterPtr<T>& p) throw ()
	{
		if (this != &p)		//if not a reference to itself
		{
			release();		//release reference to old object
			ptr = p.ptr;	//copy new object
			count = p.count;//copy counter
			++*count;
		}
		return *this;
	}

	//access to the object
	T& operator*() const throw ()
	{
		return *ptr;
	}

	//acces to a member of the object
	T* operator->() const throw()
	{
		return ptr;
	}

private:
	void release()
	{
		++*count;			//decrement number of references
		if (*count == 0)	//if last reference
		{
			delete count;	//destroy counter
			delete ptr;		//destroy object
		}
	}
};

#endif		//COUNTED_PTR_HPP

//ect_1/refsem1.cpp

#include <iostream>
#include <list>
#include <deque>
#include <algorithm>
#include "countptr.hpp"
using namespace std;

void printCountedPtr(CountedPtr<int> elem)
{
		cout << *elem << ' ';
}

int main()
{
	//type for smart pointer for this purpose
	typedef CountedPtr<int> IntPtr;

	//two different sets
	deque<IntPtr> coll1;
	list <IntPtr> coll2;

	//array of initial ints
	static int values [] = {3,5,9,1,6,4};

	/*insert newly created ints in the sets with reference semantics
	 *	-same sequence in coll1
	 *	-reversed sequence in coll2
	 */
	for (unsigned i = 0; i < sizeof(values)/sizeof(values[0]); ++i)
	{
		IntPtr ptr(new int(values[i]));
		coll1.push_back(ptr);
		coll2.push_front(ptr);
	}

	//output content of both sets
	for_each(coll1.begin(), coll1.end(), printCountedPtr);
	cout << endl;
	for_each(coll2.begin(), coll2.end(), printCountedPtr);
	cout << endl;

	/*modify elements of the sets in different places
	 *	-square third value in coll1
	 *	-negate first value in coll1
	 *	-set first value in coll2 to 0
	 */
	*coll1[2] *= *coll1[2];
	(**coll1.begin()) *= -1;
	(**coll2.begin()) = 0;

	//output content of both sets again
		for_each(coll1.begin(), coll1.end(), printCountedPtr);
	cout << endl;
	for_each(coll2.begin(), coll2.end(), printCountedPtr);
	cout << endl;

}

vector <long double>::iterator varying_start;
varying_start=vec.begin();
vector <long double>::iterator start;
start=vec.begin();



while(true)
{
	varying_start= find(varying_start,vec.end() , 0.);
	int index=varying_start-start;
}