Пост #130768

#include "StdAfx.h"

#include "c:\\mironena\\work\\SelfDev\\C++\\Projects\\Dll\\Export.h"
#pragma comment( lib, "c:\\mironena\\work\\SelfDev\\C++\\build\\bin\\Win32\\Debug\\Dll.lib" )

#include <iostream>
#include <cstring>
#include <string>
#include <set>
#include <algorithm>
#include <sstream>
#include <vector>


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


//template< typename Base, typename DerivedTypeDetails >
//class ObjectFactory
//{
//protected:
//
//    typedef void(*InstanceCreatorFunc)(Base*&);
//    typedef typename DerivedTypeDetails::KeyType KeyType;
//
//    struct ObjectType
//    {
//        InstanceCreatorFunc			pCreatorFunc;
//        const DerivedTypeDetails*	pObjectTypeDetails;
//
//        ObjectType()
//            : pCreatorFunc(NULL)
//            , pObjectTypeDetails(NULL)
//        {
//        }
//    };
//
//    //
//    // This is a map which maps strings to functions that create an
//    // object of the specified type.
//    //
//    typedef KeyValueMap< KeyType, ObjectType > ObjectTypeMap;
//
//    //
//    // Declare an additional type definition that is this particular
//    // type of object factory.
//    //
//    typedef ObjectFactory< Base, DerivedTypeDetails > FactoryType;
//
//protected:
//    //
//    // Protected Constructor
//    //
//    ObjectFactory()
//        : m_objectTypeMap()
//    {
//    }
//
//public:
//    //
//    // Here is a helper class used for registering the derived classes
//    // of type _base with the object factory, along with a pointer to a
//    // function that can create an object of that type.
//    //
//    // This is a nested class because it is a registrar for this type of factory,
//    // rather than just a general registrar that can work with any factory.
//    //
//    class Registrar
//    {
//    public:
//        Registrar(const DerivedTypeDetails&	objectTypeDetails,
//            InstanceCreatorFunc		pCreatorFunc)
//            : m_objectTypeDetails(objectTypeDetails)
//            , m_pCreatorFunc(pCreatorFunc)
//            , m_bRegistered(false)
//        {
//            registerClass();
//        }
//
//    public:
//        //
//        // Needed sometimes to force compiler to link in the registrar.
//        //
//        void registerClass()
//        {
//            if (m_bRegistered == false)
//            {
//                ObjectFactory& factory = ObjectFactory::instance();
//                factory.registerClass(m_objectTypeDetails, m_pCreatorFunc);
//                m_bRegistered = true;
//            }
//        }
//
//        bool isRegistered()
//        {
//            return m_bRegistered;
//        }
//
//    public:
//        //
//        // Private data members
//        //
//        const DerivedTypeDetails&	m_objectTypeDetails;
//        InstanceCreatorFunc			m_pCreatorFunc;
//        bool						m_bRegistered;
//    };
//
//public:
//    //
//    // Public type definitions
//    //
//    typedef typename ObjectTypeMap::KeyValueVectorType ObjectTypeVector;
//
//public:
//    //
//    // Public interface
//    //
//
//    //
//    // Singleton pattern static member for obtaining the single instance
//    // of the class.
//    //
//    static ObjectFactory& instance()
//    {
//        static ObjectFactory factory;
//        return factory;
//    }
//
//    //
//    // Destructor
//    //
//    ~ObjectFactory()
//    {
//    }
//
//    //
//    // This method will create an object of the specified type.
//    //
//    Base* createObject(const KeyType& key)
//    {
//        Base* pNewObj = NULL;
//
//        Risk::CSGuard guard(m_cs);
//
//        //
//        // Search for a map entry with the same name
//        //
//        ObjectTypeMap::iterator i = m_objectTypeMap.find(key);
//        if (i != m_objectTypeMap.end())
//        {
//            //
//            // Get a pointer to the creator function
//            //
//            InstanceCreatorFunc pCreatorFunc = (*i).second.pCreatorFunc;
//
//            //
//            // Unlock the critical section before calling the creator function
//            // Note: This may lead to race conditions
//            //
//            guard.unlock();
//
//            //
//            // Now call it to create an object of the specified type
//            //
//            (*pCreatorFunc)(pNewObj);
//        }
//
//        return pNewObj;
//    }
//
//    //
//    // Return a list of the object types this factory can create
//    //
//    void getObjectTypes(ObjectTypeVector& objecTypes)
//    {
//        m_objectTypeMap.convertToVector(objecTypes);
//    }
//
//
//protected:
//    //
//    // Protected helper functions
//    //
//
//    //
//    // This allows the Registrar to register the object creator functions
//    //
//    friend class Registrar;
//
//    //
//    // This method registers the type of objects that this factory
//    // can create.
//    //
//    void registerClass(const DerivedTypeDetails&	objectTypeDetails,
//        InstanceCreatorFunc			pCreatorFunc)
//    {
//        Risk::CSGuard guard(m_cs);
//
//        ObjectType objectType;
//        objectType.pCreatorFunc = pCreatorFunc;
//        objectType.pObjectTypeDetails = &objectTypeDetails;
//
//        m_objectTypeMap.insert(ObjectTypeMap::value_type(KeyType(objectTypeDetails.key), objectType));
//    }
//
//
//private:
//    //
//    // Private data members
//    //
//    CS			m_cs;
//
//    //
//    // This is the map which maps object names to a function
//    // that can create an object of that type.
//    //
//    ObjectTypeMap m_objectTypeMap;
//};


//struct String
//{
//
//	String(const char *str = "")
//	{
//		size_ = strlen( str );
//		str_ = new char[ size_ + 1 ];
//		strncpy( str_, str, size_+ 1 );
//	}
//
//	String(size_t n, char c)
//	{
//		size_ = n;
//		str_ = new char[ size_ + 1]();
//
//		for (int i = 0; i < size_; ++i)
//		{
//			str_[i] = c;
//		}
//		str_[size_ + 1] = '\0';
//	}
//
//	size_t size_;
//	char* str_;
//};

//namespace 
//{
//
//char* getline()
//{
//	char inputSymbol = '\0';
//	int stringLength = 1;
//	char* resultStr = new char[stringLength]();
//
//	while ( std::cin.get(inputSymbol) && inputSymbol != '\n' )
//	{
//		char* tmp = new char[ stringLength + 1 ]();
//
//		strcpy(tmp, resultStr);
//		tmp[ stringLength - 1 ] = inputSymbol;
//		delete[] resultStr;
//		resultStr = tmp;
//		++stringLength;
//	}
//
//	return resultStr;
//}
//
//void removeExtraSpaces(std::string& inputStr)
//{
//	size_t firstNonSpaceSymbol = inputStr.find_first_not_of(' ');
//	
//	if ( firstNonSpaceSymbol != std::string::npos )
//	{
//		inputStr = inputStr.substr( firstNonSpaceSymbol, inputStr.length() - firstNonSpaceSymbol );
//	}
//
//	size_t lastNonSpaceSymbol = inputStr.find_last_not_of(' ');
//	if ( lastNonSpaceSymbol != std::string::npos )
//	{
//		inputStr = inputStr.substr( 0, lastNonSpaceSymbol + 1 );
//	}
//
//	size_t repeatedSpaceLocation = inputStr.find("  ");
//	while( repeatedSpaceLocation != std::string::npos )
//	{
//		inputStr.replace( repeatedSpaceLocation, 2, " " );
//		repeatedSpaceLocation = inputStr.find("  ");
//	}
//}
//
//int** transpose(const int* const* m, size_t r, size_t c)
//{
//	int** resultMatrix = new int *[c];
//	for (unsigned int i = 0; i < c; i++)
//		resultMatrix[i] = new int[r];
//
//
//	for ( unsigned int i = 0; i < r; i++ )
//		for ( unsigned int j = 0; j < c; j++ )
//			resultMatrix[j][i] = m[i][j];
//
//	return resultMatrix;
//}
//
//void swap_min(int** mt, unsigned int m, unsigned int n)
//{
//	int rowNum = 0, minElem = mt[0][0];
//
//	for ( unsigned int i = 0; i < m; i++ )
//	{
//		for ( unsigned int j = 0; j < n; j++ )
//		{
//			if ( mt[i][j] < minElem)
//			{
//				minElem = mt[i][j];
//				rowNum = i;
//			}
//		}
//	}
//
//	if ( rowNum != 0 )
//	{
//		for ( unsigned int i = 0; i < n; ++i )
//		{
//			int tmp = mt[0][i];
//			mt[0][i] = mt[rowNum][i];
//			mt[rowNum][i] = tmp;
//		}
//	}
//}
//
//void outputMatrix(int** mt, int rows, int columns)
//{
//	for (int i = 0; i < rows; ++i )
//	{
//		for (int j = 0; j < columns; ++j)
//		{
//			std::cout << mt[i][j] << " ";
//		}
//		std::cout << std::endl;
//	}
//	std::cout << std::endl;
//}
//
//int** createAndFillMatrix(int rows, int columns)
//{
//	int** matrix = new int*[rows](); 
//	for ( int i = 0; i != rows; ++i )
//		matrix[i] = new int[columns]();
//
//	int k = 1;
//	for (int i = 0; i < rows; ++i )
//	{
//		for (int j = 0; j < columns; ++j)
//		{
//			matrix[i][j] = k;
//			++k;
//		}
//	}
//
//	return matrix;
//}
//
//void createFileMapping(const std::wstring& filePath)
//{
//	int a;
//	std::cin >> a;
//
//	TCHAR szName[] = TEXT("Global\\MyFileMappingObject");
//
//	HANDLE hFile = CreateFile(
//		filePath.c_str(),
//		GENERIC_READ | GENERIC_WRITE,
//		FILE_SHARE_READ | FILE_SHARE_WRITE,
//		NULL,
//		OPEN_EXISTING,
//		0,
//		0 );
//
//	// handle failure
//	if ( hFile == INVALID_HANDLE_VALUE )
//	{
//		_tprintf( TEXT( "Could not create file mapping object (%d).\n" ), GetLastError() );
//	}
//
//	HANDLE hFileMap = CreateFileMapping(
//		hFile,								// use paging file
//		NULL,								// default security
//		PAGE_READWRITE,						// read/write access
//		0,									// maximum object size (high-order DWORD)
//		0,									// maximum object size (low-order DWORD)
//		L"Global\\MyFileMappingObject" );	// name of mapping object
//
//	if ( hFileMap == NULL )
//	{
//		_tprintf( TEXT( "Could not create file mapping object (%d).\n" ), GetLastError() );
//	}
//}
//
//}


template<unsigned long N>
struct binary
{
	static unsigned long const value =
		binary<N / 10>::value << 1 | N % 10;
};

template <> struct binary<0>
{
	static unsigned long const value = 0;
};

int binary_conv(int binary)
{
	if (binary == 0)
		return 0;

	return binary_conv(binary / 10) << 1 | binary % 10;
}

std::vector<std::string>&& xvalue_func()
{
	static std::vector<std::string> vec;
	vec = std::vector<std::string>(2, "Hola");

	return std::move(vec);
}

int main()
{
//*************************************************************************
// 	const int ROWS = 3, COLUMNS = 3;
// 
// 	int** matrix = createAndFillMatrix( ROWS, COLUMNS );
// 	outputMatrix( matrix, ROWS, COLUMNS );
// 
// 	swap_min(matrix, ROWS, COLUMNS);
// 	outputMatrix( matrix, ROWS, COLUMNS );
// 
// 	int** result = transpose(matrix, ROWS, COLUMNS);
// 	outputMatrix( matrix, COLUMNS, ROWS );

//*************************************************************************
// 	std::string someStr;
// 	std::getline( std::cin, someStr );
// 
// 	int** matrixVar; 
// 	removeExtraSpaces( someStr );

//	std::cout << someStr;
//*************************************************************************
//	int myints[] = {10,20,30,30,20,10,10,20};
//	std::multiset<int> int_map(myints, myints+8);
//
//	auto iter = int_map.lower_bound( 20 );
//	std::cout << "Upperbound value: " << *int_map.upper_bound(20) << std::endl;
//	std::cout << "Lowerbound value: " << *iter << std::endl;
//	std::for_each(iter, int_map.end(), [=](int var)
//	{
//		std::cout  << var << " ";
//	});
//*************************************************************************

	std::wcout << binary_conv(101) << std::endl;
	std::wcout << binary<101>::value << std::endl;

//*************************************************************************

	std::vector<std::string> value = xvalue_func();
	value.push_back("Hello");
	std::cout << "size= " << value.size() << std::endl;
	std::vector<std::string>::iterator it = value.begin();
	while (it != value.end()) std::cout << *it++ << std::endl;

	std::vector<std::string>&& v = xvalue_func();
	v.push_back("Guten tag");
	std::cout << "size= " << v.size() << std::endl;
	it = v.begin();
	while (it != v.end()) std::cout << *it++ << std::endl;

	v = xvalue_func();
	std::cout << "size= " << v.size() << std::endl;
	it = v.begin();
	while (it != v.end()) std::cout << *it++ << std::endl;


	return 0;
}