Beginning Visual C++ 6

// TrialRun.cpp
// Our first program
#include <iostream>

using namespace std;

int main()
{
   // code as shown in book
}

The missing line is shown in the screenshot on the following page and is used throughout the rest of the book. 'using namespace std;' allows routines from the C++ standard library to be incorporated into the program (in this case 'cout'). The using directive and namespaces are explained on pages 42 and 85 to 88.

The second sentence of the paragraph introducing the 'Try It Out' concludes with an erroneous statement. The sentence should simply read as follows:

However, it's still possible to get at the global variable using the scope resolution operator (::).

Namespaces are discussed in Chapter 2, not Chapter 1. The scope resolution operator is not discussed until Chapter 8.

The second sentence on page 85 should read as follows:

We'll talk further about namespaces, including how to create your own, shortly.

In exercise 2_08.cpp, the line,

std::cin << value;

should read as follows:

std::cin >> value;

The third sentence on the page should read as follows:

Of course, you would not usually organize a source file in this way deliberately, but it can arise quite naturally with header files that you include into a program.





Thanks to Ryan McLaughlin

Some readers have asked for clarification regarding the use and behavior of cin.getline() as it compares to using the << operator. In particular, a problem can arise when the former is used immediately after the latter.

These two techniques of obtaining input differ in the way they deal with the carriage return that typically terminates text entered by the user. Specifically, << doesn't remove the carriage return from the input stream, but cin.getline() does. A potential consequence of this is that when cin.getline() is called after using <<, it finds the carriage return that's been left in the input buffer and returns immediately, offering the user no opportunity to provide the input you were seeking.

If you need to use cin.getline() after using <<, one option available to you is to call cin.ignore() before doing so, as this will remove the stray carriage return from the input buffer.

In Visual C++ 6, unlike Visual C++ 5, hexadecimal numbers are not prefixed by 0x when they appear on screen.

appearing between the quotes and terminated with /0
should read
appearing between the quotes and terminated with \0

At the bottom of the page, there should be an opening bracket ( between static_cast<int> and 2.0.

#include <iostream>
#include <cstdlib>
using namespace std;

The section that occupies the majority of this and the following page is misleading. To use the _set_new_handler() function, it's necessary to include the new.h header file in your code, rather than the standard library file new that the book identifies. However, it's also possible to include new, and then to use the standard library function set_new_handler() (note the lack of a leading underscore) instead.

In the function eatspaces, the return statement is unnecssary.

if(*(str+i) != ' ')
  i++;

if(*(str+i) != ' ')
{
  i++;
}

In the final line of the figure at the top of page 234, the factor should be 0.001 (not 0.01, as shown).

The penultimate line of the extract() function on page 238 is superfluous - the program will compile and run with or without it. The exit(1); command ends the program, thus rendering the return pstr; line that follows it redundant. (It removes any need to return from the function at this point.)

In the answer to Exercise 6-1, the variable P[i] in the final line of the function should be enclosed in brackets:

return static_cast<int>(p[i]);

The WINAPI specifier in both the WindowProc() function definition on page 272 and its prototype on page 273 should be replaced with CALLBACK, so that they read as follows:

long CALLBACK WindowProc(...)

The function header double volume() should be followed by the keyword const.

CBox(double lv, double bv = 1.0, double hv = 1.0): m_Length(lv), m_Breadth(bv), m_Height(hv)
{
   cout << endl << "Constructor called.";
}

CBox(double lv, double bv = 1.0, double hv = 1.0): m_Length(lv), m_Breadth(bv), m_Height(hv)
{
   cout << endl << "Constructor called.";
   objectCount++;
}

The model answers to Exercises 8-2 and 8-3 use destructors, which aren't covered until the next chapter.

void DisplayMessage(CMessage localMsg)
{
   cout << endl << "The message is: ";
   localMsg.ShowIt();

   return;
}

Motto1 = *pMess;

motto1 = *pMess;

The second comment (// Class definition at global scope) wraps on to the next line. "scope" is not a command!

CSamples()
{
  m_Free = 0;
}

int m_Free;   // Index of free location in m_Values

At the top of page 363, the return statement includes a static_cast with a bracket instead of an angled bracket. The line should read as follows:

return static_cast<int>(...code as shown in book...);

The second parameter of the CBox multiply operator should be a reference. The next-to-last line in the list of declarations for global box operators should read as follows:

CBox operator*(int n, const CBox& aBox);

When you follow the book's instructions for running macros, you may find yourself confronted by a blank Macro dialog box. Should this happen to you, there's a relatively easy fix.

With no files open in Visual C++6, you need to click on Tools | Macro. Then, in the Macro dialog box that appears, you have to click on Options | Loaded Files. Finally, in the Add-ins and Macro Files tab of the Customize dialog box that appears, you need to enable the Sample macro by clicking on the check box. After you've closed the dialog, you can follow the book's directions to run the macro.

In the final line of the first bullet point, "default constructor" should read, "default destructor".

The destructor in listing 10_01-02 should not have a semicolon after the closing curly bracket.

The first line of the first paragraph in the section entitled "Constructor Operation in a Derived Class" should read as follows:

Although we said that the base class constructor is not inherited in the derived class, it still exists for the base part of the derived class object.

In the paragraph below the screenshot, the third sentence should read as follows:

For the other objects, the correct destructor calls occur with the derived class destructor being called first, followed by the base class destructor.

Due to what appears to be a bug in the ClassWizard, using the Add Member Function dialog to add the assignment operator to the CCalculator class will not work. An implementation will be provided in the Calculator.cpp file but no declaration will be added to the class definition in Calculator.h.

Consequently you shouldn't bother with the Wizard and should add the declaration manually. The declaration should be placed in the private section of the class, as shown on page 445.

As stated in the book, no implementation is needed - if you've used the Wizard to add the assignment operator function you should delete the implementation that the Wizard produces.

class CCalculator
{
  public:
    void Run() const;
    CCalculator();
    virtual ~CCalculator();
  private:
    CCalculator(const CCalculator& rCalculator);
    CCalculator& operator=(const CCalculator& rhs);
    CKeyboard* m_pKeyboard;
    CLogicUnit* m_pLogicUnit;
    CDisplay* m_pDisplay;
};

In later editions, the sentence,
"If you have used ClassWizard to add the operator function, you will need to delete the implementation as it is added automatically",
is added to the first paragraph on the page.

The function CLogicUnit::OnDigit() should be declared as:

void OnDigit(const int& digit);

This amendment to the function's parameter also applies to the declaration of OnDigit() shown on page 452 and its implementation shown on page 453.

Some of the values shown in the table do not accurately reflect the workings of the code.
When the '+' is entered the values held in the registers should be as follows:
Display = 1.5
Multiply = 1.5
Add = 1.5

When '5' is entered the values should be:
Display = 5
Multiply = 1.5
Add = 1.5

When 'Enter' is pressed, the values should be:
Display = 6.5
Multiply = 1.5
Add = 6.5

Thanks to Sasa Bosnjak.

The OnDigit function should be declared as follows.
void OnDigit(const int& digit);

In the CRegister class, the OnDigit() function should be declared as follows:

void OnDigit(const int& digit);

The parameter of the function CRegister::OnDigit() should be:

const int& digi

The CRegister member variable m_bBeginValue should be declared as bool (as stated in the text) rather than int (as shown in the code).

In the comments in the definition of the operator+ function, R1 and R2 should be replaced by reg1 and reg2.

The second line of code at the bottom of the page should end m_pCalc(pCalc) with an underscore rather than a hyphen.

The incomplete declaration of the CRegister class (which you are told to add) is missing from the contents of the file Display.h. The following line should be placed immediately above the incomplete declaration of CCalculator:

class CRegister;

First 3 lines of the function declaration should read:

int main()
{
long* pnumber = NULL;
long number1 = 55;
long number2 = 99;





Thanks to Clinton Hess

On the final line "withhandling" should read "with handling".

In the second sentence of the section entitled Functions Checking the Free Store, ctrdbg.h should read crtdbg.h.

The preprocessor symbol _NDEBUG should be _DEBUG.

The first sentence of the second paragraph on page 535 should read as follows:

Each arrow in the diagram points to a derived class from its base class.

The final sentence on the page should read:

. Create a new header file and add the following skeleton code:



Thanks to David Sneed

In the code at the top of the page, a comment, // Get the bounding rectangle for an element, has wrapped to the next line.

void CSketcherView::OnMouseMove(UINT nFlags, CPoint point)
{
  //Define a Device Context object for the view
  CClientDC aDC(this);
  if((nFlags & MK_LBUTTON) & (this == GetCapture()))

An extra argument has been included in the constructor for the line object. The final argument should not be added until the next chapter, so the constructor declaration should read as follows: CLine(const CPoint& Start, const CPoint& End, const COLORREF& Color);

The constructor declaration in the CLine class should read as follows:CLine(const CPoint& Start, const CPoint& End, const COLORREF& Color, const int& PenWidth);

There are two references to, 'DLLs which don't involve MFC' - a topic which is not covered in the book. The first is in the bulleted list on page 785 and the second is in the 'Writing DLLs' section on page 792.

The last sentence in the section entitled Writing DLLs which reads &quotFinally, we will cover how to write plain Windows DLLs which do not involve MFC at all." should be deleted.

void CDBSampleView::OnEditorder()
{
  if( m_pSet->CanUpdate() )
  {
    try
    {
      if (m_UpdateMode)
      {
        m_EditCtrl.SetWindowText("Edit Order");
        m_Abort.ShowWindow(SW_HIDE);
        UpdateData(true);  //Added Line
        m_pSet->Update();
      }
      else
      {
         
       ...

UpdateData(FALSE);

void COrderDetailsView::OnCancel() 
{
  m_pSet->CancelUpdate();
  UpdateData(FALSE);
  m_EditCtrl.SetWindowText("Edit");
  m_CancelCtrl.ShowWindow(SW_HIDE);
  m_QuantityCtrl.SetReadOnly(m_UpdateMode);
  m_DiscountCtrl.SetReadOnly(m_UpdateMode);
  m_UpdateMode = !m_UpdateMode;
}

​ In the definition of InitializeView(), m_CompanyName should be replaced with m_CustomerName. The fourth line in the body of the function should read:
m_CustomerName = pDoc->m_Order.m_ShipName;

We need to override the default implementation of the OnUpdate() function in order to make use of the hint information passed in the second and third parameters. Add this function to the CWrxContainerView class using ClassWizard, giving the return type as void and the name as OnUpdate(CView* pSender, LPARAM lHint, CObject *pHint). The implementation is shown below:

void CWrxContainerView::OnUpdate(CView *pSender, LPARAM lHint, CObject *pHint)
{
  if(lHint==HINT_UPDATE_ITEM)
  {
    //We need to pass a rectangle to InvalidateRect() for the item
    //that takes account of the tracker
    CRectTracker tracker;  //The tracker
    SetupTracker((CWrxContainerItem*)pHint, &tracker);  //...setup for the item
    CRect rect;
    tracker.GetTrueRect(rect);  //Get the tracker rectangle
    InvalidateRect(rect);  //and invalidate that.
  } 
  else
  {
    InvalidateRect(0);
  }
}

CRect aRect = static_cast<CElement*>
(pHint)->GetBoundRect();

In the third paragraph on page 982, the menu option that you should select is:

//Definition of constants
#ifndef __OURCONSTANTS_H__
#define __OURCONSTANTS_H__

const int STOP          = 101;
const int GO            = 103;
const int READY_TO_STOP = 104;

const COLORREF RED      = RGB(255, 0, 0);
const COLORREF ORANGE   = RGB(200, 100, 0);
const COLORREF GREEN    = RGB(0, 255, 0);
const COLORREF GRAY     = RGB(100, 100, 100);

#endif

The CSignal constructor should include the following line (which is added by the ATL COM AppWizard):

In the OnDraw function definition at the bottom of the page, the first line should read

HRESULT OnDraw(ATL_DRAWINFO& di)

Inthe same function definition, the static_cast is inappropriate. Therefore the first line in the body of the function should read

RECT& rc = *(RECT*)di.prcBounds; // Get control rectangle

In the definition of StartSignal(), the call to SetSignalState() should be a call to SetState(). The second line in the body of the function should, therefore, read as follows:

In the first paragraph on page 1054, SetTimer() is described as having three arguments. In fact, the version of SetTimer() used here only has two arguments, as shown in the StartSignal() function definition. The two arguments are the timer ID and the time interval in milliseconds.

The screenshot should reflect the fact that the states are 101, 103, 104 (not 101, 102, 103).

The keywords shown below should be included in the list:

export
wchar_t


The following are not Visual C++ keywords:

bad_cast
bad_typeid
type_info

The answer to exercise 2-4 should have only one of the arguments in the division cast to a double, as described in the text but not as shown in the line of code. The line of code should read as follows:

The code as shown in the book will produce the answer 1 (when dividing 640 by 480). This is because both width and height are integer variables and therefore the result of (width/height) will be an integer also; the nearest integer to the actual result of 1.333 being 1. Only when the division has been performed is the result cast to a double (i.e. the integer 1 is cast to the double 1.0).
In the correct version only width is cast to a double. Width is then divided by the integer height, producing a result that is a double (in this case 1.333).

void CSketcherDoc::OnUpdateColorBlack(CCmdUI* pCmdUI)
{
  //Set menu item checked if the current color is black
  pCmdUI->SetCheck(m_Color==BLACK);
  
  //Set upper case for a selected item, lower case otherwise
  if(m_Color == BLACK)
    pCmdUI->SetText("BLACK");
  else
    pCmdUI->SetText("black");
}

When you create the recordset class, CEmployeeSet, based on the employee table, the wizard will create the class with member variables corresponding to all the fields in the table. As you can see from the constructor shown on page 1135, most of these members have been deleted using ClassWizard, leaving only the 3 fields we need. Care should be take when deleting fields from a recordset class not to delete the key field(s).

In the second paragraph on page 1136, the text reads "To control the list box, add another variable to CCustomerView". Note that you should use ClassWizard to add this variable, m_EmployeeCtrl. As well as adding the member variable to the header file (as shown in the code snippet), the wizard will automaically add the following line to the DoDataExchange() method in the .cpp file:DDX_Control(pDX, IDC_EMPLOYEENAME, m_EmployeeCtrl);Remember that this function controls the exchange of values between data members and dialog controls.

Note that in the code shown for CCustomerView::OnInitialUpdate() at the bottom of page 1136, a call to SetNewOrderID() is shown. This is superfluous, as the method has already been called from CMainFrame::SelectView().

In the first paragraph on page 1138, the text states "the listbox handler we added to CCustomerView ...". Note that you need to add this handler at this point using ClassWizard.