#include <iostream>
#include <vector>
#include <memory>
using namespace std;

class Base_t {
public:
   virtual ~Base_t() {}
   virtual int foo(int x) const = 0;
};

class derived1_t : public Base_t {
public:
   ~derived1_t() {}
   int foo(int x) const override {
      return 1111 + x;
   }
};

class derived2_t : public Base_t {
public:
   ~derived2_t() {}
   int foo(int x) const override {
      return 2222 + x;
   }
};

using container_t = vector<shared_ptr<Base_t>>;

int main() {
   container_t cont;
   Base_t* d1 = new derived1_t();
   Base_t* d2 = new derived2_t();
//    cont.push_back(d1);
//    cont.push_back(make_shared<Base_t>(new derived2_t()));
   cont.emplace_back(d1);
   cont.emplace_back(new derived2_t());
   cont.emplace_back(new derived1_t());
   cont.emplace_back(d2);

   int ii = 0;
   for (auto elem : cont) { cout << elem->foo(++ii) << endl; }
}

Select all Open in new window

1>    \emplace_back_and_make_shared.cpp(34): error C2664: 'void std::vector<std::shared_ptr<Base_t>,std::allocator<_Ty>>::push_back(_Ty &&)': cannot convert argument 1 from 'Base_t *' to 'const _Ty &'
1>            with
1>            [
1>                _Ty=std::shared_ptr<Base_t>
1>            ]
1>    \emplace_back_and_make_shared.cpp(33): note: Reason: cannot convert from 'Base_t *' to 'const _Ty'
1>            with
1>            [
1>                _Ty=std::shared_ptr<Base_t>
1>            ]
1>    \emplace_back_and_make_shared.cpp(34): note: Constructor for class 'std::shared_ptr<Base_t>' is declared 'explicit'
1>    1 Error

Select all Open in new window

prog.cpp:34:22: error: no matching function for call to ‘std::vector<std::shared_ptr<Base_t> >::push_back(Base_t*&)’
     cont.push_back(d1);
                      ^

Select all Open in new window

Select all Open in new window

int main()
{
	PointerToNormalMemberFunction(); // target 1
	PointerToTemplateMemberFunction(); // target 2
	PointerToTemplateMemberFunctionWithTwoParameters(); // terget 3
	PointerToTemplateMemberInTemplateClass(); // target 4
//	HoldingAPointerToTemplateMemberInTemplateClass(); // target 5 ---> Had to comment this out
}

Select all Open in new window

#pragma once

#include <iostream>

template<typename TYPE>
class Target5
{
public:
	Target5(const TYPE &value) : value(value) {}
	TYPE value;

	template <typename T>
	void OneParam(T a)
	{
		std::cout << "Target5::OneParam(" << value << "," << a << ")\n";

		typedef void (Target5<E>::*MethodTypeToCall)(T);
		// Here, the compiler picks the right overload
		MethodTypeToCall toCall = &Target5<E>::Private;
		// In this case, the compiler does not let us write the following line (parse error):
		//MethodTypeToCall toCall = &Target5<E>::Private<t;;
		(this->*toCall)(a);
	}

	template <typename T1, typename T2>
	void TwoParam(T1 a, T2 b)
	{
		std::cout << "Target5::TwoParam(" << value << "," << a << "," << b << ")\n";

		typedef 

Select all Open in new window

      WCHAR *printable = new WCHAR[(dwBufferSize+1)*2];
      printable[0] = '\0';

      for (unsigned long i =0;i<dwBufferSize;i++)
      {
         WCHAR scratch[3];
		 wsprintf(scratch,L"%02X", pBuffer[i]);   //This is the problem code. wsprintf requires LPSTR but scratch is WCHAR
         wcscat(printable, scratch);
      }

      *pbstrEncrypted = SysAllocStringLen(printable, dwBufferSize*2);

I've looked for code on the internet to convert a variable from WCHAR to LPSTR and back again. I could make do with that.  As near as I can see the wsprintf with the format 
code %02X takes a single wide char and makes it two hex output characters and concatenates it to the printable variable. This code was written in 2000.

Bob


      delete [] printable;

Select all Open in new window

Str greeting = "Hello, " + name + "!";

Select all Open in new window

#include <iterator>
#include <vector>
#include<iostream>

using namespace std;

class Str
{

private:
    std::vector<char> data;

public:
    typedef std::vector<char>::size_type size_type;
    typedef std::vector<char>::iterator iterator;
    typedef std::vector<char>::const_iterator const_iterator;

    iterator begin() { return data.begin(); }
    const_iterator begin() const { return data.begin(); }
    iterator end() { return data.end(); }
    const_iterator end() const { return data.end(); }


    // default constructor must be defined explicitly, since non-default constructors are also defined
    Str() { }
    Str(const size_type n, const char c) : data(n, c) {  }
    Str(const char* cp)
    {
        std::copy(cp, cp + std::strlen(cp), std::back_inserter(data));

Select all Open in new window

IDirectorySearch *pDSSearch;
ADS_SEARCH_COLUMN col;
hr = pDSSearch->SetSearchPreference(rgSearchPrefs, ARRAYSIZE(rgSearchPrefs));
hr = pDSSearch->ExecuteSearch(strFilter, pszAttr ,dwAttrNameSize, &hSearch );

if(SUCCEEDED(hr))
	{						
		switch(col.dwADsType)
		{ 
			case  ADSTYPE_DN_STRING:
			case ADSTYPE_CASE_IGNORE_STRING:
				{			
					for(size_t x=0; x<col.dwNumValues;x++)
					{
						CString name = col.pADsValues[x].CaseIgnoreString; //fails for unicode text
					}
				}
		}
	}

Select all Open in new window