C / C++ / MFC

Dim o As Object 'will be an Outlook.Application
Dim msg As Object 'will be a MailItem

Set o = CreateObject("Outlook.Application")
Set msg = o.CreateItem(0)
msg.Subject = "this is my subject"

msg.attachments.Add "path to the attachment"

msg.body = "my message"

msg.Recipients.Add "an e-mail address"

msg.send

#import "progid:Outlook.Application" auto_search

int main(int, char**)
{
   try
   {
      CoInitializeEx(0, COINIT_APARTMENTTHREADED);
      Outlook::_ApplicationPtr ol(__uuidof(Outlook::Application));
      Outlook::_MailItemPtr msg(ol->CreateItem(Outlook::olMailItem));

      msg->Subject = "this is my subject";
      
      msg->Attachments->Add("path to the attachment");

      // If execution gets here, the attachment's been added to msg, and you can go on and do other stuff!
      
      msg->Body = "my message";
      
      msg->Recipients->Add("an e-mail address");
      
      msg->Send();
   }
   catch (_com_error& e)
   {
      std::cerr << (char*)e.Description() << std::endl;
   }
   return 0;
}

sharion wrote:

If doesn't find, then enter base class---Super class to find it.
above explanation is correct?

sharion wrote:

when the compiler runs ref.someMethod();

sharion wrote:

If the someMethod() in Sub class is

virtual void someMethod(int i = 1){cout<<"in Sub class"<<endl}

when the compiler runs ref.someMethod(); statement,what is the output?
In VS 2005,the output is "in Super class". I feel it is hard to understand,I believe the right result is "in Sub class".

std::string strText;
std::stringstream ssBuf;
ssBuf.imbue(std::locale::classic()); // This line tells the stringstream to use the classic locale
ssBuf<<55555;
ssBuf>>strText;

std::string strText;
std::stringstream ssBuf;
std::locale l;
l = l.combine<std::numpunct<char> >(std::locale::classic());
ssBuf.imbue(l);
ssBuf<<55555;
ssBuf>>strText;

Cedric Moonen wrote:

Great reply, got my 5

Cedric Moonen wrote:

Don't you consider writing an article for CP ?

Stuart Dootson wrote:

Your locale[^] is getting in the way.

class CTimer
{
public:
   CTimer(std::string const& what) : what_(what) { QueryPerformanceFrequency((LARGE_INTEGER*)&freq_); begin_ = Now(); }
   ~CTimer() { end_ = Now(); ShowTime(end_ - begin_); }
private:
   __int64 Now()
   {
      __int64 now;
      QueryPerformanceCounter((LARGE_INTEGER*)&now);
      // Now divide now by freq_ to get seconds - I generally scale before the division to get microseconds or nanoseconds
      return the time you calculated;
   }
   void ShowTime(__int64 deltaTime) { std::cout << "Doing " << what_ << /* Display deltaTime nicely */ << std::endl; }
   __int64 begin_, end_;
   __int64 freq_;
   const std::string what_;
};
// in my code
   {
      CTimer t("some message");
      // Do something lengthy
   } // A message is displayed when t goes out of scope, showing the time taken over it's lifetime, whic is near enough the time for the lengthy bit