Cargando…
Ivor Horton's beginning Visual C++ 2012 /
The only book to teach C++ programming with Microsoft Visual Studio! There's a reason why Ivor Horton's Beginning Visual C++ books dominate the marketplace. Ivor Horton has a loyal following who love his winning approach to teaching programming languages, and in this fully updated new edit...
| Clasificación: | Libro Electrónico |
|---|---|
| Autor principal: | |
| Formato: | Electrónico eBook |
| Idioma: | Inglés |
| Publicado: |
Hoboken, N.J. : Chichester :
Wiley ; John Wiley [distributor],
2012.
|
| Colección: | Wrox beginning guides.
|
| Temas: | |
| Acceso en línea: | Texto completo (Requiere registro previo con correo institucional) |
MARC
| LEADER | 00000cam a2200000 a 4500 | ||
|---|---|---|---|
| 001 | OR_ocn812917869 | ||
| 003 | OCoLC | ||
| 005 | 20231017213018.0 | ||
| 006 | m o d | ||
| 007 | cr cnu---unuuu | ||
| 008 | 121015s2012 njua o 001 0 eng d | ||
| 040 | |a N$T |b eng |e pn |c N$T |d E7B |d KNOVL |d B24X7 |d COO |d YDXCP |d TEFOD |d KNOVL |d OCLCF |d DG1 |d K6U |d CDX |d OCLCO |d DKDLA |d MHW |d EBLCP |d CAUOI |d UMI |d DEBSZ |d TEFOD |d OCLCQ |d OCLCO |d OCLCQ |d OCLCO |d DEBBG |d AZK |d OCLCQ |d OCLCO |d DG1 |d MOR |d LIP |d PIFAG |d LIV |d MERUC |d OCLCQ |d GWDNB |d ZCU |d U3W |d BUF |d COCUF |d OCLCQ |d STF |d WRM |d OCLCO |d CEF |d ICG |d INT |d NRAMU |d VT2 |d OCLCQ |d OCLCO |d WYU |d TKN |d OCLCQ |d OCLCO |d UAB |d OCLCQ |d A6Q |d DKC |d OCLCO |d OCLCQ |d UKAHL |d OCLCQ |d OCLCO |d OCLCQ |d UKOBU |d UKCRE |d BRF |d OCLCQ |d OCLCO |d OCLCQ |d OCLCO | ||
| 015 | |a GBB264956 |2 bnb | ||
| 016 | 7 | |a 1060045028 |2 DE-101 | |
| 016 | 7 | |a 1066911029 |2 DE-101 | |
| 016 | 7 | |a 016117945 |2 Uk | |
| 019 | |a 815384241 |a 844729533 |a 847028783 |a 848895187 |a 955258584 |a 961625020 |a 962694776 |a 988412529 |a 991959710 |a 992922561 |a 1037761514 |a 1038638762 |a 1045525941 |a 1058558275 |a 1065937982 |a 1081282110 |a 1083598397 |a 1096215444 |a 1103269371 |a 1129330987 |a 1152973092 |a 1153547430 |a 1192350436 |a 1228610898 |a 1240527653 | ||
| 020 | |a 9781118983997 |q (electronic bk.) | ||
| 020 | |a 1118983998 |q (electronic bk.) | ||
| 020 | |a 9781118439418 |q (electronic bk.) | ||
| 020 | |a 1118439414 |q (electronic bk.) | ||
| 020 | |a 9781621982289 |q (electronic bk.) | ||
| 020 | |a 1621982289 |q (electronic bk.) | ||
| 020 | |a 9781118417034 |q (electronic bk.) | ||
| 020 | |a 1118417038 |q (electronic bk.) | ||
| 020 | |a 9781118434314 |q (electronic bk.) | ||
| 020 | |a 1118434315 |q (electronic bk.) | ||
| 020 | |z 9781118368084 | ||
| 020 | |z 1118368088 | ||
| 029 | 1 | |a AU@ |b 000050415372 | |
| 029 | 1 | |a AU@ |b 000052007215 | |
| 029 | 1 | |a AU@ |b 000053284536 | |
| 029 | 1 | |a AU@ |b 000058062803 | |
| 029 | 1 | |a AU@ |b 000067103794 | |
| 029 | 1 | |a CHBIS |b 010259718 | |
| 029 | 1 | |a CHNEW |b 000609976 | |
| 029 | 1 | |a CHNEW |b 000940727 | |
| 029 | 1 | |a CHVBK |b 480210306 | |
| 029 | 1 | |a DEBBG |b BV041430883 | |
| 029 | 1 | |a DEBBG |b BV043395119 | |
| 029 | 1 | |a DEBBG |b BV044049774 | |
| 029 | 1 | |a DEBSZ |b 382171500 | |
| 029 | 1 | |a DEBSZ |b 38310033X | |
| 029 | 1 | |a DEBSZ |b 397283687 | |
| 029 | 1 | |a DEBSZ |b 398266972 | |
| 029 | 1 | |a DEBSZ |b 485028026 | |
| 029 | 1 | |a GBVCP |b 1014965381 | |
| 029 | 1 | |a GWDNB |b 1060045028 | |
| 029 | 1 | |a GWDNB |b 1066911029 | |
| 029 | 1 | |a NZ1 |b 14795146 | |
| 029 | 1 | |a NZ1 |b 15622711 | |
| 029 | 1 | |a NZ1 |b 15912111 | |
| 035 | |a (OCoLC)812917869 |z (OCoLC)815384241 |z (OCoLC)844729533 |z (OCoLC)847028783 |z (OCoLC)848895187 |z (OCoLC)955258584 |z (OCoLC)961625020 |z (OCoLC)962694776 |z (OCoLC)988412529 |z (OCoLC)991959710 |z (OCoLC)992922561 |z (OCoLC)1037761514 |z (OCoLC)1038638762 |z (OCoLC)1045525941 |z (OCoLC)1058558275 |z (OCoLC)1065937982 |z (OCoLC)1081282110 |z (OCoLC)1083598397 |z (OCoLC)1096215444 |z (OCoLC)1103269371 |z (OCoLC)1129330987 |z (OCoLC)1152973092 |z (OCoLC)1153547430 |z (OCoLC)1192350436 |z (OCoLC)1228610898 |z (OCoLC)1240527653 | ||
| 037 | |a CL0500000223 |b Safari Books Online | ||
| 037 | |a 8986363D-DC92-4938-A65F-59BC7EF0C4F1 |b OverDrive, Inc. |n http://www.overdrive.com | ||
| 050 | 4 | |a QA76.73.C153 |b H679 2012eb | |
| 072 | 7 | |a COM |x 051310 |2 bisacsh | |
| 072 | 7 | |a COM |x 051280 |2 bisacsh | |
| 072 | 7 | |a COM |x 051130 |2 bisacsh | |
| 082 | 0 | 4 | |a 005.133 |2 23 |
| 049 | |a UAMI | ||
| 100 | 1 | |a Horton, Ivor. | |
| 245 | 1 | 0 | |a Ivor Horton's beginning Visual C++ 2012 / |c Ivor Horton. |
| 246 | 3 | 0 | |a Beginning Visual C++ 2012 |
| 246 | 3 | 0 | |a Ivor Horton's beginning Visual C Plus Plus 2012 |
| 246 | 3 | 0 | |a Beginning Visual C Plus Plus 2012 |
| 260 | |a Hoboken, N.J. : |b Wiley ; |a Chichester : |b John Wiley [distributor], |c 2012. | ||
| 300 | |a 1 online resource (xl, 942 pages) : |b illustrations | ||
| 336 | |a text |b txt |2 rdacontent | ||
| 337 | |a computer |b c |2 rdamedia | ||
| 338 | |a online resource |b cr |2 rdacarrier | ||
| 347 | |a data file | ||
| 490 | 1 | |a Wrox beginning guides | |
| 588 | 0 | |a Print version record. | |
| 520 | |a The only book to teach C++ programming with Microsoft Visual Studio! There's a reason why Ivor Horton's Beginning Visual C++ books dominate the marketplace. Ivor Horton has a loyal following who love his winning approach to teaching programming languages, and in this fully updated new edition, he repeats his successful formula. Offering a comprehensive introduction to both the standard C++ language and to Visual C++, he offers step-by-step programming exercises, examples, and solutions to deftly guide novice programmers through the ins and outs of C++ development. Introduces novice programmers. | ||
| 505 | 0 | 0 | |g Machine generated contents note: |g ch. 1 |t Programming With Visual C++ -- |t Learning with Visual C++ -- |t Writing C++ Applications -- |t Learning Desktop Applications Programming -- |t Learning C++ -- |t Console Applications -- |t Windows Programming Concepts -- |t What Is the Integrated Development Environment? -- |t Editor -- |t Compiler -- |t Linker -- |t Libraries -- |t Using the IDE -- |t Toolbar Options -- |t Dockable Toolbars -- |t Documentation -- |t Projects and Solutions -- |t Defining a Project -- |t Debug and Release Versions of Your Program -- |t Executing the Program -- |t Dealing with Errors -- |t Setting Options in Visual C++ -- |t Creating and Executing Windows Applications -- |t Creating an MFC Application -- |t Building and Executing the MFC Application -- |t Summary -- |g ch. 2 |t Data, Variables, and Calculations -- |t Structure of a C++ Program -- |t Program Comments -- |t #include Directive -- Header Files -- |t Namespaces and the Using Declaration -- |t main() Function -- |t Program Statements -- |t Whitespace -- |t Statement Blocks -- |t Automatically Generated Console Programs -- |t Precompiled Header Files -- |t Main Function Names -- |t Defining Variables -- |t Naming Variables -- |t Keywords in C++ -- |t Declaring Variables -- |t Initial Values for Variables -- |t Fundamental Data Types -- |t Integer Variables -- |t Character Data Types -- |t Integer Type Modifiers -- |t Boolean Type -- |t Floating-Point Types -- |t Fundamental Types in C++ -- |t Literals -- |t Defining Synonyms for Data Types -- |t Basic Input/Output Operations -- |t Input from the Keyboard -- |t Output to the Command Line -- |t Formatting the Output -- |t Escape Sequences -- |t Calculating in C++ -- |t Assignment Statement -- |t Arithmetic Operations -- |t const Modifier -- |t Constant Expressions -- |t Program Input -- |t Calculating the Result -- |t Displaying the Result -- |t Calculating a Remainder -- |t Modifying a Variable -- |t Increment and Decrement Operators -- |t Sequence of Calculation -- |t Operator Precedence -- |t Type Conversion and Casting -- |t Type Conversion in Assignments -- |t Explicit Type Conversion -- |t Old-Style Casts -- |t auto Keyword -- |t Discovering Types -- |t Bitwise Operators -- |t Bitwise AND -- |t Bitwise OR -- |t Bitwise Exclusive OR -- |t Bitwise NOT -- |t Bitwise Shift Operators -- |t Introducing Lvalues and Rvalues -- |t Understanding Storage Duration and Scope -- |t Automatic Variables -- |t Positioning Variable Declarations -- |t Global Variables -- |t Static Variables -- |t Variables with Specific Sets of Values -- |t Old Enumerations -- |t Type-Safe Enumerations -- |t Namespaces -- |t Declaring a Namespace -- |t Multiple Namespaces -- |t Summary -- |g ch. 3 |t Decisions and Loops -- |t Comparing Values -- |t if Statement -- |t Nested if Statements -- |t Extended if Statement -- |t Nested if-else Statements -- |t Logical Operators and Expressions -- |t Logical AND -- |t Logical OR -- |t Logical NOT -- |t Conditional Operator -- |t switch Statement -- |t Unconditional Branching -- |t Repeating a Block of Statements -- |t What Is a Loop? -- |t Variations on the for Loop -- |t Using the continue Statement -- |t Floating-Point Loop Counters -- |t while Loop -- |t do-while Loop -- |t Range-Based for Loop -- |t Nested Loops -- |t Summary -- |g ch. 4 |t Arrays, Strings, and Pointers -- |t Handling Multiple Data Values of the Same Type -- |t Arrays -- |t Declaring Arrays -- |t Initializing Arrays -- |t Using the Range-Based for Loop -- |t Character Arrays and String Handling -- |t String Input -- |t Using the Range-Based for Loop with Strings -- |t Multidimensional Arrays -- |t Initializing Multidimensional Arrays -- |t Indirect Data Access -- |t What Is a Pointer? -- |t Declaring Pointers -- |t Address-Of Operator -- |t Using Pointers -- |t Indirection Operator -- |t Why Use Pointers? -- |t Initializing Pointers -- |t Pointers to char -- |t sizeof Operator -- |t Constant Pointers and Pointers to Constants -- |t Pointers and Arrays -- |t Pointer Arithmetic -- |t Using Pointers with Multidimensional Arrays -- |t Pointer Notation with Multidimensional Arrays -- |t Dynamic Memory Allocation -- |t Free Store, Alias the Heap -- |t new and delete Operators -- |t Allocating Memory Dynamically for Arrays -- |t Dynamic Allocation of Multidimensional Arrays -- |t Using References -- |t What Is a Reference? -- |t Declaring and Initializing Lvalue References -- |t Using References in a Range-Based for Loop -- |t Rvalue References -- |t Library Functions for Strings -- |t Finding the Length of a Null-Terminated String -- |t Joining Null-Terminated Strings -- |t Copying Null-Terminated Strings -- |t Comparing Null-Terminated Strings -- |t Searching Null-Terminated Strings -- |t Summary -- |g ch. 5 |t Introducing Structure Into Your Programs -- |t Understanding Functions -- |t Why Do You Need Functions? -- |t Structure of a Function -- |t Function Header -- |t Function Body -- |t return Statement -- |t Alternative Function Syntax -- |t Using a Function -- |t Function Prototypes -- |t Passing Arguments to a Function -- |t Pass-by-Value Mechanism -- |t Pointers as Arguments to a Function -- |t Passing Arrays to a Function -- |t Passing Multidimensional Arrays to a Function -- |t References as Arguments to a Function -- |t Use of the const Modifier -- |t Rvalue Reference Parameters -- |t Arguments to main() -- |t Accepting a Variable Number of Function Arguments -- |t Returning Values from a Function -- |t Returning a Pointer -- |t Cast-iron Rule for Returning Addresses -- |t Returning a Reference -- |t Teflon-Coated Rule: Returning References -- |t Static Variables in a Function -- |t Recursive Function Calls -- |t Using Recursion -- |t Summary -- |g ch. 6 |t More About Program Structure -- |t Pointers to Functions -- |t Declaring Pointers to Functions -- |t Pointer to a Function as an Argument -- |t Arrays of Pointers to Functions -- |t Initializing Function Parameters -- |t Exceptions -- |t Throwing Exceptions -- |t Catching Exceptions -- |t Rethrowing Exceptions -- |t Exception Handling in the MFC -- |t Handling Memory Allocation Errors -- |t Function Overloading -- |t What Is Function Overloading? -- |t Reference Types and Overload Selection -- |t When to Overload Functions -- |t Function Templates -- |t Using a Function Template -- |t Using the decltype Operator -- |t Example Using Functions -- |t Implementing a Calculator -- |t Analyzing the Problem -- |t Eliminating Blanks from a String -- |t How the Function Functions -- |t Evaluating an Expression -- |t How the Function Functions -- |t Getting the Value of a Term -- |t How the Function Functions -- |t Analyzing a Number -- |t How the Function Functions -- |t Putting the Program Together -- |t How the Function Functions -- |t Extending the Program -- |t How the Function Functions -- |t Extracting a Substring -- |t How the Function Functions -- |t Running the Modified Program -- |t Summary -- |g ch. 7 |t Defining Your Own Data Types -- |t struct in C++ -- |t What Is a struct? -- |t Defining a struct -- |t Initializing a struct -- |t Accessing the Members of a struct -- |t IntelliSense Assistance with Structures -- |t struct RECT -- |t Using Pointers with a struct -- |t Accessing Structure Members through a Pointer -- |t Indirect Member Selection Operator -- |t Types, Objects, Classes, and Instances -- |t First Class -- |t Operations on Classes -- |t Terminology -- |t Understanding Classes -- |t Defining a Class -- |t Access Control in a Class -- |t Declaring Objects of a Class -- |t Accessing the Data Members of a Class -- |t Member Functions of a Class -- |t Positioning a Member Function Definition -- |t Inline Functions -- |t Class Constructors -- |t What Is a Constructor? -- |t Default Constructor -- |t Default Parameter Values -- |t Using an Initialization List in a Constructor -- |t Making a Constructor Explicit -- |t Private Members of a Class -- |t Accessing private Class Members -- |t friend Functions of a Class -- |t Placing friend Function Definitions Inside the Class -- |t Default Copy Constructor -- |t Pointer this -- |t const Objects -- |t const Member Functions of a Class -- |t Member Function Definitions Outside the Class -- |t Arrays of Objects -- |t Static Members of a Class -- |t Static Data Members -- |t Static Function Members of a Class -- |t Pointers and References to Objects -- |t Pointers to Objects -- |t References to Class Objects -- |t Implementing a Copy Constructor -- |t Summary -- |g ch. |
| 505 | 0 | 0 | |t 8 |t More on Classes -- |t Class Destructors -- |t What Is a Destructor? -- |t Default Destructor -- |t Destructors and Dynamic Memory Allocation -- |t Implementing a Copy Constructor -- |t Sharing Memory Between Variables -- |t Defining Unions -- |t Anonymous Unions -- |t Unions in Classes and Structures -- |t Operator Overloading -- |t Implementing an Overloaded Operator -- |t Implementing Full Support for Comparison Operators -- |t Overloading the Assignment Operator -- |t Fixing the Problem -- |t Overloading the Addition Operator -- |t Overloading the Increment and Decrement Operators -- |t Overloading the Function Call Operator -- |t Object Copying Problem -- |t Avoiding Unnecessary Copy Operations -- |t Applying Rvalue Reference Parameters -- |t Named Objects are Lvalues -- |t Default Class Members -- |t Class Templates -- |t Defining a Class Template -- |t Template Member Functions -- |t Creating Objects from a Class Template -- |t Class Templates with Multiple Parameters -- |t Templates for Function Objects -- |t Perfect Forwarding -- |t Using Classes -- |t Idea of a Class Interface -- |t Defining the Problem -- |t Implementing the CBox Class -- |t Comparing CBox Objects -- |t Combining CBox Objects -- |t Analyzing CBox Objects -- |t Organizing Your Program Code -- |t Naming Program Files -- |t Library Classes for Strings -- |t Creating String Objects -- |t Concatenating Strings -- |t Accessing and Modifying Strings -- |t Comparing Strings -- |t Searching Strings -- |t Summary -- |g ch. 9 |t Class Inheritance and Virtual Functions -- |t Object-Oriented Programming Basics -- |t Inheritance in Classes -- |t What Is a Base Class? -- |t Deriving Classes from a Base Class -- |t Access Control Under Inheritance. |
| 505 | 0 | 0 | |g Note continued: |t Constructor Operation in a Derived Class -- |t Declaring Protected Class Members -- |t Access Level of Inherited Class Members -- |t Copy Constructor in a Derived Class -- |t Preventing Class Derivation -- |t Class Members as Friends -- |t Friend Classes -- |t Limitations on Class Friendship -- |t Virtual Functions -- |t What Is a Virtual Function? -- |t Ensuring Correct Virtual Function Operation -- |t Preventing Function Overriding -- |t Using Pointers to Class Objects -- |t Using References with Virtual Functions -- |t Incomplete Class Declaration -- |t Pure Virtual Functions -- |t Abstract Classes -- |t Indirect Base Classes -- |t Virtual Destructors -- |t Casting Between Class Types -- |t Nested Classes -- |t Summary -- |g ch. 10 |t Standard Template Library -- |t What Is the Standard Template Library? -- |t Containers -- |t Allocators -- |t Comparators -- |t Container Adapters -- |t Iterators -- |t Iterator Categories -- |t SCARY Iterators -- |t std::begin() and std::end() Functions -- |t Smart Pointers -- |t Using unique_ptr Objects -- |t Using shared_ptr Objects -- |t Accessing the Raw Pointer in a Smart Pointer -- |t Casting SmartPointers -- |t Algorithms -- |t Function Objects in the STL -- |t Function Adapters -- |t Range of STL Containers -- |t Sequence Containers -- |t Creating Vector Containers -- |t Capacity and Size of a Vector Container -- |t Accessing the Elements in a Vector -- |t Inserting and Deleting Elements in a Vector -- |t Insert Operations -- |t Emplace Operations -- |t Erase Operations -- |t Swap and Assign Operations -- |t Storing Class Objects in a Vector -- |t Sorting Vector Elements -- |t Storing Pointers in a Vector -- |t Array Containers -- |t Double-Ended Queue Containers -- |t Using List Containers -- |t Adding Elements to a List -- |t Accessing Elements in a List -- |t Sorting List Elements -- |t Other Operations on Lists -- |t Using forward_list Containers -- |t Using Other Sequence Containers -- |t Queue Containers -- |t Priority Queue Containers -- |t Stack Containers -- |t tuple Class Template -- |t Associative Containers -- |t Using Map Containers -- |t Storing Objects -- |t Accessing Objects -- |t Other Map Operations -- |t Using a Multimap Container -- |t More on Iterators -- |t Using Input Stream Iterators -- |t Using Inserter Iterators -- |t Using Output Stream Iterators -- |t More on Function Objects -- |t More on Algorithms -- |t Type Traits and Static Assertions -- |t Lambda Expressions -- |t Capture Clause -- |t Capturing Specific Variables -- |t Templates and Lambda Expressions -- |t Naming a Lambda Expression -- |t Summary -- |g ch. 11 |t Windows Programming Concepts -- |t Windows Programming Basics -- |t Elements of a Window -- |t Windows Programs and the Operating System -- |t Event-Driven Programs -- |t Windows Messages -- |t Windows API -- |t Windows Data Types -- |t Notation in Windows Programs -- |t Structure of a Windows Program -- |t WinMain() Function -- |t Specifying a Program Window -- |t Creating a Program Window -- |t Initializing the Program Window -- |t Dealing with Windows Messages -- |t Complete WinMain() Function -- |t How It Works -- |t Processing Windows Messages -- |t WindowProc() Function -- |t Decoding a Windows Message -- |t Ending the Program -- |t Complete WindowProc() Function -- |t How It Works -- |t Microsoft Foundation Classes -- |t MFC Notation -- |t How an MFC Program Is Structured -- |t Summary -- |g ch. 12 |t Windows Programming With the Microsoft Foundation Classes (MFC) -- |t MFC Document/View Concept -- |t What Is a Document? -- |t Document Interfaces -- |t What Is a View? -- |t Linking a Document and Its Views -- |t Document Templates -- |t Document Template Classes -- |t Your Application and MFC -- |t Creating MFC Applications -- |t Creating an SDI Application -- |t MFC Application Wizard Output -- |t Viewing Project Files -- |t Viewing Classes -- |t Class Definitions -- |t Creating an Executable Module -- |t Running the Program -- |t How the Program Works -- |t Creating an MDI Application -- |t Running the Program -- |t Summary -- |g ch. 13 |t Working With Menus And Toolbars -- |t Communicating with Windows -- |t Understanding Message Maps -- |t Message Handler Definitions -- |t Message Categories -- |t Handling Messages in Your Program -- |t How Command Messages Are Processed -- |t Extending the Sketcher Program -- |t Elements of a Menu -- |t Creating and Editing Menu Resources -- |t Adding a Menu Item to the Menu Bar -- |t Adding Items to the Element Menu -- |t Modifying Existing Menu Items -- |t Completing the Menu -- |t Adding Menu Message Handlers -- |t Choosing a Class to Handle Menu Messages -- |t Creating Menu Message Handlers -- |t Implementing Menu Message Handlers -- |t Adding Members to Store Color and Element Mode -- |t Defining Element and Color Types -- |t Initializing the Color and Element Type Members -- |t Implementing Menu Command Message Handlers -- |t Running the Extended Example -- |t Adding Menu Update Message Handlers -- |t Coding a Command Update Handler -- |t Exercising the Update Handlers -- |t Adding Toolbar Buttons -- |t Editing Toolbar Button Properties -- |t Exercising the Toolbar Buttons -- |t Adding Tooltips -- |t Summary -- |g ch. 14 |t Drawing in a Window -- |t Basics of Drawing in a Window -- |t Window Client Area -- |t Windows Graphical Device Interface -- |t Working with a Device Context -- |t Mapping Modes -- |t MFC Drawing Mechanism -- |t View Class in Your Application -- |t OnDraw() Member Function -- |t CDC Class -- |t Displaying Graphics -- |t Drawing in Color -- |t Drawing Graphics in Practice -- |t Programming for the Mouse -- |t Messages from the Mouse -- |t Wm_Lbuttondown -- |t Wm_Mousemove -- |t Wm_Lbuttonup -- |t Mouse Message Handlers -- |t Drawing Using the Mouse -- |t Getting the Client Area Redrawn -- |t Defining Element Classes -- |t CElement Class -- |t CLine Class -- |t CRectangle Class -- |t CCircle Class -- |t CCurve Class -- |t Completing the Mouse Message Handlers -- |t Drawing a Sketch -- |t Running the Example -- |t Capturing Mouse Messages -- |t Summary -- |g ch. 15 |t Improving The View -- |t Sketcher Limitations -- |t Improving the View -- |t Updating Multiple Views -- |t Scrolling Views -- |t Logical Coordinates and Client Coordinates -- |t Dealing with Client Coordinates -- |t Using MM_LOENGLISH Mapping Mode -- |t Deleting and Moving Elements -- |t Implementing a Context Menu -- |t Associating a Menu with a Class -- |t Checking Context Menu Items -- |t Identifying an Element under the Cursor -- |t Exercising the Context Menus -- |t Highlighting Elements -- |t Drawing Highlighted Elements -- |t Exercising the Highlights -- |t Implementing Move and Delete -- |t Deleting an Element -- |t Moving an Element -- |t Updating Other Views -- |t Getting the Elements to Move Themselves -- |t Dropping the Element -- |t Exercising the Application -- |t Dealing with Masked Elements -- |t Summary -- |g ch. 16 |t Working With Dialogs and Controls -- |t Understanding Dialogs -- |t Understanding Controls -- |t Creating a Dialog Resource -- |t Adding Controls to a Dialog -- |t Testing the Dialog -- |t Programming for a Dialog -- |t Adding a Dialog Class -- |t Modal and Modeless Dialogs -- |t Displaying a Dialog -- |t Displaying the Dialog -- |t Code to Close the Dialog -- |t Supporting the Dialog Controls -- |t Initializing Dialog Controls -- |t Handling Radio Button Messages -- |t Completing Dialog Operations -- |t Adding Pen Widths to the Document -- |t Adding Pen Widths to the Elements -- |t Creating Elements in the View -- |t Exercising the Dialog -- |t Using a Spin Button Control -- |t Adding a Scale Menu Item and Toolbar Button -- |t Creating the Spin Button -- |t Controls' Tab Sequence -- |t Generating the Scale Dialog Class -- |t Dialog Data Exchange and Validation -- |t Initializing the Dialog -- |t Displaying the Spin Button -- |t Using the Scale Factor -- |t Scalable Mapping Modes -- |t Setting the Document Size -- |t Setting the Mapping Mode -- |t Implementing Scrolling with Scaling -- |t Setting Up the Scrollbars -- |t Working with Status Bars -- |t Adding a Status Bar to a Frame -- |t Creating Status Bar Panes -- |t Updating the Status Bar -- |t CString Class -- |t Using an Edit Box Control -- |t Creating an Edit Box Resource -- |t Creating the Dialog Class -- |t Adding the Text Menu Item -- |t Defining a Text Element -- |t Implementing the CText Class -- |t CText Constructor -- |t Creating a Text Element -- |t Drawing a CText Object -- |t Moving a CText Object -- |t Summary -- |g ch. |
| 505 | 0 | 0 | |t 17 |t Storing and Printing Documents -- |t Understanding Serialization -- |t Serializing a Document -- |t Serialization in the Document Class Definition -- |t Serialization in the Document Class Implementation -- |t Serialize() Function -- |t CArchive Class -- |t Functionality of CObject-Based Classes -- |t Macros that Add Serialization to a Class -- |t How Serialization Works -- |t How to Implement Serialization for a Class -- |t Applying Serialization -- |t Recording Document Changes -- |t Serializing the Document -- |t Serializing the Element Classes -- |t Serialize() Functions for the Element Classes -- |t Exercising Serialization -- |t Printing a Document -- |t Printing Process -- |t CPrintInfo Class -- |t Implementing Multipage Printing -- |t Getting the Overall Document Size -- |t Storing Print Data -- |t Preparing to Print -- |t Cleaning Up after Printing -- |t Preparing the Device Context -- |t Printing the Document -- |t Getting a Printout of the Document -- |t Summary -- |g ch. 18 |t Programming Windows 8 Apps -- |t Understanding Windows 8 Apps -- |t Developing Windows 8 Apps -- |t Windows Runtime Concepts -- |t WinRT Namespaces -- |t WinRT Objects -- |t C++ Component Extensions (C++/CX) -- |t C++/CX Namespaces -- |t Defining WinRT Class Types -- |t Variables of Ref Class Types -- |t Accessing Members of a Ref Class Object -- |t Event Handler Functions -- |t Casting Ref Class References -- |t extensible Application Markup Language (XAML) -- |t XAML Elements -- |t UI Elements in XAML -- |t Attached Properties -- |t Parents and Children -- |t Control Elements -- |t Layout Elements -- |t Handling Events for UI Elements -- |t Creating a Windows 8 App. |
| 505 | 0 | 0 | |g Note continued: |t Application Files -- |t Defining the User Interface -- |t Creating the Title -- |t Adding Game Controls -- |t Creating a Grid to Contain the Cards -- |t Defining a Card -- |t Creating a Card -- |t Adding Event Handling -- |t Creating All the Cards -- |t Implementing Game Operations -- |t Defining the Card Class -- |t Adding Data Members to the MainPage Class -- |t Adding Function Members -- |t Initialize the MainPage Object -- |t Initializing the Card Pack -- |t Setting Up the Child Elements of cardGrid -- |t Initializing the Game -- |t Shuffling the Cards -- |t Highlighting the UI Cards -- |t Handling Card Back Events -- |t Handling Shape Events -- |t Recognizing a Win -- |t Handling Game Control Button Events -- |t Scaling UI Elements -- |t Transitions -- |t Application Startup Transitions -- |t Storyboard Animations -- |t Summary. |
| 590 | |a O'Reilly |b O'Reilly Online Learning: Academic/Public Library Edition | ||
| 630 | 0 | 0 | |a Microsoft Visual C++. |
| 630 | 0 | 7 | |a Microsoft Visual C++ |2 blmlsh |
| 630 | 0 | 7 | |a Microsoft Visual C++ |2 fast |
| 650 | 0 | |a C++ (Computer program language) | |
| 650 | 6 | |a C++ (Langage de programmation) | |
| 650 | 7 | |a COMPUTERS |x Programming Languages |x C# |2 bisacsh | |
| 650 | 7 | |a COMPUTERS |x Programming Languages |x Java. |2 bisacsh | |
| 650 | 7 | |a COMPUTERS |x Programming Languages |x Pascal. |2 bisacsh | |
| 650 | 7 | |a C++ (Computer program language) |2 fast | |
| 776 | 0 | 8 | |i Print version: |a Horton, Ivor. |t Ivor Horton's beginning Visual C++ 2012. |d Hoboken, N.J. : Wiley ; Chichester : John Wiley [distributor], 2012 |z 9781118368084 |w (OCoLC)798409545 |
| 830 | 0 | |a Wrox beginning guides. | |
| 856 | 4 | 0 | |u https://learning.oreilly.com/library/view/~/9781118417034/?ar |z Texto completo (Requiere registro previo con correo institucional) |
| 938 | |a Askews and Holts Library Services |b ASKH |n AH24487327 | ||
| 938 | |a Askews and Holts Library Services |b ASKH |n AH24669988 | ||
| 938 | |a Books 24x7 |b B247 |n bks00049519 | ||
| 938 | |a Coutts Information Services |b COUT |n 24025685 | ||
| 938 | |a EBL - Ebook Library |b EBLB |n EBL894311 | ||
| 938 | |a ebrary |b EBRY |n ebr10606028 | ||
| 938 | |a EBSCOhost |b EBSC |n 485576 | ||
| 938 | |a YBP Library Services |b YANK |n 11903883 | ||
| 938 | |a YBP Library Services |b YANK |n 9733567 | ||
| 938 | |a YBP Library Services |b YANK |n 9808274 | ||
| 994 | |a 92 |b IZTAP | ||