Klienditugi: 7440010 (E-R 10-18)

Abi | Registreeri | Logi sisse

Professional Cplusplus 4th edition [Pehme köide]

4.31/5 (126 hinnangut Goodreads-ist)

Marc Gregoire

Formaat: Paperback / softback, 1184 pages, kõrgus x laius x paksus: 234x188x69 mm, kaal: 1610 g
Ilmumisaeg: 05-Jun-2018
Kirjastus: Wrox Press
ISBN-10: 1119421306
ISBN-13: 9781119421306

Teised raamatud teemal:

Programming & scripting languages: general - (Hetkel poes: 1 nimetust)
Object-oriented programming (OOP)

Pehme köide
Hind: 77,50 €*
* saadame teile pakkumise kasutatud raamatule, mille hind võib erineda kodulehel olevast hinnast
See raamat on trükist otsas, kuid me saadame teile pakkumise kasutatud raamatule.
Kogus:
- - 1
  - 2
  - 3
  - 4
  - 5
  - 6
  - 7
  - 8
  - 9
  - 10
Lisa ostukorvi
Tasuta tarne
Lisa soovinimekirja
Raamatukogudele

Formaat: Paperback / softback, 1184 pages, kõrgus x laius x paksus: 234x188x69 mm, kaal: 1610 g
Ilmumisaeg: 05-Jun-2018
Kirjastus: Wrox Press
ISBN-10: 1119421306
ISBN-13: 9781119421306

Teised raamatud teemal:

Programming & scripting languages: general - (Hetkel poes: 1 nimetust)
Object-oriented programming (OOP)

Püsilink: https://www.kriso.ee/db/9781119421306.html

Märksõnad:

C++ (Computer program language)

Get up to date quickly on the big changes coming with C++17

Professional C++ is the advanced manual for C++ programming. Designed to help experienced developers get more out of the latest release, this book skims over the basics and dives right in to exploiting the full capabilities of C++17. Each feature is explained by example, each including actual code snippets that you can plug into your own applications. Case studies include extensive, working code that has been tested on Windows, Linux, and Solaris, and the author's expert tips, tricks, and workarounds can dramatically enhance your workflow. Even many experienced developers have never fully explored the boundaries of the language's capabilities; this book reveals the advanced features you never knew about, and drills down to show you how to turn these features into real-world solutions.

The C++17 release includes changes that impact the way you work with C++; this new fourth edition covers them all, including nested namespaces, structured bindings, string_view, template argument deduction for constructors, math functions, parallel algorithms, generalized sum algorithms, Boyer-Moore string searching, string conversion primitives, a filesystem API, clamping values, optional values, the variant type, the any type, and more. Clear explanations and professional-level depth make this book an invaluable resource for any professional needing to get up to date quickly.

Maximize C++ capabilities with effective design solutions
Master little-known elements and learn what to avoid
Adopt new workarounds and testing/debugging best practices
Utilize real-world program segments in your own applications

C++ is notoriously complex, and whether you use it for gaming or business, maximizing its functionality means keeping up to date with the latest changes. This time, those changes are extensive—and whether they enhance your work or make it harder depends on how well-versed you are in the newest C++ features. Professional C++ gets you up to date quickly, and provides the answers you need for everyday solutions.

Introduction

xlvii

Part I: Introduction To Professional C++

Chapter 1 A Crash Course In C++ And The Standard Library

(54)

The Basics of C++

(24)

The Obligatory Hello, World

(4)

Comments

(1)

Preprocessor Directives

(1)

The main() Function

(1)

I/O Streams

(1)

Namespaces

(2)

Literals

(1)

Variables

(3)

Operators

(2)

Types

(2)

Enumerated Types

(1)

Structs

(1)

Conditional Statements

(3)

if/else Statements

(1)

switch Statements

(2)

The Conditional Operator

(1)

Logical Evaluation Operators

(1)

Functions

(2)

Function Return Type Deduction

(1)

Current Function's Name

(1)

C-Style Arrays

(2)

std::array

(1)

std::vector

(1)

Structured Bindings

(1)

Loops

(2)

The while Loop

(1)

The do/while Loop

(1)

The for Loop

(1)

The Range-Based for Loop

(1)

Initializer Lists

(1)

Those Are the Basics

(1)

Diving Deeper into C++

(12)

Strings in C++

(1)

Pointers and Dynamic Memory

(6)

The Stack and the Heap

(1)

Working with Pointers

(1)

Dynamically Allocated Arrays

(1)

Null Pointer Constant

(1)

Smart Pointers

(2)

The Many Uses of const

(1)

const Constants

(1)

const to Protect Parameters

(1)

References

(2)

Pass By Reference

(1)

Pass By const Reference

(1)

Exceptions

(1)

Type Inference

(2)

The auto Keyword

(1)

The decltype Keyword

(1)

C++ as an Object-Oriented Language

(3)

Defining Classes

(3)

Using Classes

(1)

Uniform Initialization

(3)

Direct List Initialization versus Copy List Initialization

(1)

The Standard Library

(1)

Your First Useful C++ Program

(10)

An Employee Records System

(1)

The Employee Class

(3)

Employee.h

(1)

Employee.cpp

(2)

EmployeeTest.cpp

(1)

The Database Class

(3)

Database.h

(1)

Database.cpp

(1)

DatabaseTest.cpp

(1)

The User Interface

(2)

Evaluating the Program

(1)

Summary

(1)

Chapter 2 Working With Strings And String Views

(14)

Dynamic Strings

(11)

C-Style Strings

(2)

String Literals

(2)

Raw String Literals

(2)

The C++ std::string Class

(5)

What Is Wrong with C-Style Strings?

(1)

Using the string Class

(2)

std::string Literals

(1)

High-Level Numeric Conversions

(1)

Low-Level Numeric Conversions

(2)

The std::string_view Class

(2)

std::string_view Literals

(1)

Nonstandard Strings

(1)

Summary

(2)

Chapter 3 Coding With Style

(24)

The Importance of Looking Good

(1)

Thinking Ahead

(1)

Elements of Good Style

(1)

Documenting Your Code

(9)

Reasons to Write Comments

(5)

Commenting to Explain Usage

(2)

Commenting to Explain Complicated Code

(1)

Commenting to Convey Meta-information

(2)

Commenting Styles

(4)

Commenting Every Line

(1)

Prefix Comments

(1)

Fixed-Format Comments

(1)

Ad Hoc Comments

(1)

Self-Documenting Code

(1)

Decomposition

(2)

Decomposition through Refactoring

(1)

Decomposition by Design

(1)

Decomposition in This Book

(1)

Naming

(3)

Choosing a Good Name

(1)

Naming Conventions

(2)

Counters

(1)

Prefixes

(1)

Hungarian Notation

(1)

Getters and Setters

(1)

Capitalization

(1)

Namespaced Constants

(1)

Using Language Features with Style

(2)

Use Constants

(1)

Use References Instead of Pointers

(1)

Use Custom Exceptions

(1)

Formatting

(2)

The Curly Brace Alignment Debate

(1)

Coming to Blows over Spaces and Parentheses

(1)

Spaces and Tabs

(1)

Stylistic Challenges

(1)

Summary

(4)

Part II: Professional C++ Software Design

Chapter 4 Designing Professional C++ Programs

(28)

What Is Programming Design?

(1)

The Importance of Programming Design

(2)

Designing for C++

(1)

Two Rules for C++ Design

100

(3)

Abstraction

100

(1)

Benefiting from Abstraction

100

(1)

Incorporating Abstraction in Your Design

101

(1)

Reuse

101

(2)

Writing Reusable Code

102

(1)

Reusing Designs

103

(1)

Reusing Existing Code

103

(11)

A Note on Terminology

104

(1)

Deciding Whether or Not to Reuse Code

105

(2)

Advantages to Reusing Code

105

(1)

Disadvantages to Reusing Code

105

(1)

Putting It Together to Make a Decision

106

(1)

Strategies for Reusing Code

107

(5)

Understand the Capabilities and Limitations

107

(1)

Understand the Performance

108

(2)

Understand Platform Limitations

110

(1)

Understand Licensing and Support

110

(1)

Know Where to Find Help

111

(1)

Prototype

111

(1)

Bundling Third-Party Applications

112

(1)

Open-Source Libraries

112

(2)

The Open-Source Movements

112

(1)

Finding and Using Open-Source Libraries

113

(1)

Guidelines for Using Open-Source Code

113

(1)

The C++ Standard Library

114

(1)

C Standard Library

114

(1)

Deciding Whether or Not to Use the Standard Library

114

(1)

Designing a Chess Program

114

(7)

Requirements

115

(1)

Design Steps

115

(9)

Divide the Program into Subsystems

115

(2)

Choose Threading Models

117

(1)

Specify Class Hierarchies for Each Subsystem

118

(1)

Specify Classes, Data Structures, Algorithms, and Patterns for Each Subsystem

118

(2)

Specify Error Handling for Each Subsystem

120

(1)

Summary

121

(2)

Chapter 5 Designing With Objects

123

(20)

Am I Thinking Procedurally?

124

(1)

The Object-Oriented Philosophy

124

(3)

Classes

124

(1)

Components

125

(1)

Properties

125

(1)

Behaviors

126

(1)

Bringing It All Together

126

(1)

Living in a World of Objects

127

(2)

Over-Objectification

127

(1)

Overly General Objects

128

(1)

Object Relationships

129

(9)

The Has-A Relationship

129

(1)

The Is-A Relationship (Inheritance)

130

(2)

Inheritance Techniques

130

(1)

Polymorphism versus Code Reuse

131

(1)

The Fine Line between Has-A and Is-A

132

(3)

The Not-A Relationship

135

(1)

Hierarchies

136

(1)

Multiple Inheritance

137

(1)

Mixin Classes

138

(1)

Abstraction

138

(4)

Interface versus Implementation

138

(1)

Deciding on an Exposed Interface

139

(2)

Consider the Audience

139

(1)

Consider the Purpose

139

(2)

Consider the Future

141

(1)

Designing a Successful Abstraction

141

(1)

Summary

142

(1)

Chapter 6 Designing For Reuse

143

(20)

The Reuse Philosophy

144

(1)

How to Design Reusable Code

144

(15)

Use Abstraction

145

(1)

Structure Your Code for Optimal Reuse

146

(7)

Avoid Combining Unrelated or Logically Separate Concepts

146

(2)

Use Templates for Generic Data Structures and Algorithms

148

(2)

Provide Appropriate Checks and Safeguards

150

(1)

Design for Extensibility

151

(2)

Design Usable Interfaces

153

(5)

Design Interfaces That Are Easy to Use

153

(4)

Design General-Purpose Interfaces

157

(1)

Reconciling Generality and Ease of Use

157

(1)

The SOLID Principles

158

(1)

Summary

159

(4)

Part III: C++ Coding The Professional Way

Chapter 7 Memory Management

163

(36)

Working with Dynamic Memory

164

(13)

How to Picture Memory

164

(2)

Allocation and Deallocation

166

(2)

Using new and delete

166

(1)

What about My Good Friend malloc?

167

(1)

When Memory Allocation Fails

167

(1)

Arrays

168

(7)

Arrays of Basic Types

168

(2)

Arrays of Objects

170

(1)

Deleting Arrays

171

(1)

Multi-dimensional Arrays

172

(3)

Working with Pointers

175

(2)

A Mental Model for Pointers

175

(1)

Casting with Pointers

176

(1)

Array-Pointer Duality

177

(2)

Arrays Are Pointers!

177

(2)

Not All Pointers Are Arrays!

179

(1)

Low-Level Memory Operations

179

(3)

Pointer Arithmetic

179

(1)

Custom Memory Management

180

(1)

Garbage Collection

181

(1)

Object Pools

182

(1)

Smart Pointers

182

(10)

unique_ptr

183

(3)

Creating unique_ptrs

183

(2)

Using unique_ptrs

185

(1)

unique_ptr and C-Style Arrays

186

(1)

Custom Deleters

186

(1)

shared_ptr

186

(3)

Casting a shared_ptr

187

(1)

The Need for Reference Counting

188

(1)

Aliasing

189

(1)

weak_ptr

189

(1)

Move Semantics

190

(1)

enable_shared_from_this

191

(1)

The Old Deprecated/Removed auto_ptr

192

(1)

Common Memory Pitfalls

192

(5)

Underallocating Strings

192

(1)

Accessing Out-of-Bounds Memory

193

(1)

Memory Leaks

194

(3)

Finding and Fixing Memory Leaks in Windows with Visual C++

195

(1)

Finding and Fixing Memory Leaks in Linux with Valgrind

196

(1)

Double-Deleting and Invalid Pointers

197

(1)

Summary

197

(2)

Chapter 8 Gaining Proficiency With Classes And Objects

199

(32)

Introducing the Spreadsheet Example

200

(1)

Writing Classes

200

(8)

Class Definitions

200

(3)

Class Members

201

(1)

Access Control

201

(2)

Order of Declarations

203

(1)

In-Class Member Initializers

203

(1)

Defining Methods

203

(4)

Accessing Data Members

204

(1)

Calling Other Methods

204

(2)

The this Pointer

206

(1)

Using Objects

207

(1)

Objects on the Stack

207

(1)

Objects on the Heap

207

(1)

Object Life Cycles

208

(22)

Object Creation

208

(16)

Writing Constructors

209

(1)

Using Constructors

210

(1)

Providing Multiple Constructors

211

(1)

Default Constructors

212

(3)

Constructor Initializers

215

(3)

Copy Constructors

218

(2)

Initializer-List Constructors

220

(2)

Delegating Constructors

222

(1)

Summary of Compiler-Generated Constructors

222

(2)

Object Destruction

224

(1)

Assigning to Objects

225

(3)

Declaring an Assignment Operator

225

(1)

Defining an Assignment Operator

226

(1)

Explicitly Defaulted and Deleted Assignment Operator

227

(1)

Compiler-Generated Copy Constructor and Copy Assignment Operator

228

(1)

Distinguishing Copying from Assignment

228

(5)

Objects as Return Values

228

(1)

Copy Constructors and Object Members

229

(1)

Summary

230

(1)

Chapter 9 Mastering Classes And Objects

231

(46)

Friends

232

(1)

Dynamic Memory Allocation in Objects

233

(18)

The Spreadsheet Class

233

(2)

Freeing Memory with Destructors

235

(1)

Handling Copying and Assignment

236

(7)

The Spreadsheet Copy Constructor

239

(1)

The Spreadsheet Assignment Operator

240

(2)

Disallowing Assignment and Pass-By-Value

242

(1)

Handling Moving with Move Semantics

243

(7)

Rvalue References

243

(2)

Implementing Move Semantics

245

(3)

Testing the Spreadsheet Move Operations

248

(2)

Implementing a Swap Function with Move Semantics

250

(1)

Rule of Zero

250

(1)

More about Methods

251

(7)

static Methods

251

(1)

const Methods

251

(2)

mutable Data Members

253

(1)

Method Overloading

253

(2)

Overloading Based on const

254

(1)

Explicitly Deleting Overloads

255

(1)

Inline Methods

255

(2)

Default Arguments

257

(1)

Different Kinds of Data Members

258

(5)

static Data Members

258

(2)

Inline Variables

259

(1)

Accessing static Data Members within Class Methods

259

(1)

Accessing static Data Members Outside Methods

260

(1)

const static Data Members

260

(1)

Reference Data Members

261

(1)

const Reference Data Members

262

(1)

Nested Classes

263

(1)

Enumerated Types inside Classes

264

(1)

Operator Overloading

265

(7)

Example: Implementing Addition for SpreadsheetCells

265

(4)

First Attempt: The add Method

265

(1)

Second Attempt: Overloaded operator+ as a Method

266

(2)

Third Attempt: Global operator+

268

(1)

Overloading Arithmetic Operators

269

(1)

Overloading the Arithmetic Shorthand Operators

269

(1)

Overloading Comparison Operators

270

(1)

Building Types with Operator Overloading

271

(1)

Building Stable Interfaces

272

(3)

Using Interface and Implementation Classes

272

(3)

Summary

275

(2)

Chapter 10 Discovering Inheritance Techniques

277

(56)

Building Classes with Inheritance

278

(13)

Extending Classes

278

(3)

A Client's View of Inheritance

279

(1)

A Derived Class' View of Inheritance

280

(1)

Preventing Inheritance

281

(1)

Overriding Methods

281

(10)

How I Learned to Stop Worrying and Make Everything virtual

281

(1)

Syntax for Overriding a Method

282

(1)

A Client's View of Overridden Methods

283

(1)

The override Keyword

284

(2)

The Truth about virtual

286

(4)

Preventing Overriding

290

(1)

Inheritance for Reuse

291

(3)

The WeatherPrediction Class

291

(1)

Adding Functionality in a Derived Class

292

(1)

Replacing Functionality in a Derived Class

293

(1)

Respect Your Parents

294

(7)

Parent Constructors

294

(2)

Parent Destructors

296

(1)

Referring to Parent Names

297

(2)

Casting Up and Down

299

(2)

Inheritance for Polymorphism

301

(7)

Return of the Spreadsheet

301

(1)

Designing the Polymorphic Spreadsheet Cell

301

(1)

The SpreadsheetCell Base Class

302

(2)

A First Attempt

302

(1)

Pure Virtual Methods and Abstract Base Classes

303

(1)

The Individual Derived Classes

304

(2)

StringSpreadsheetCell Class Definition

304

(1)

StringSpreadsheetCell Implementation

304

(1)

DoubleSpreadsheetCell Class Definition and Implementation

305

(1)

Leveraging Polymorphism

306

(1)

Future Considerations

306

(2)

Multiple Inheritance

308

(4)

Inheriting from Multiple Classes

308

(1)

Naming Collisions and Ambiguous Base Classes

309

(3)

Name Ambiguity

309

(2)

Ambiguous Base Classes

311

(1)

Uses for Multiple Inheritance

312

(1)

Interesting and Obscure Inheritance Issues

312

(20)

Changing the Overridden Method's Characteristics

313

(3)

Changing the Method Return Type

313

(2)

Changing the Method Parameters

315

(1)

Inherited Constructors

316

(4)

Special Cases in Overriding Methods

320

(7)

The Base Class Method Is static

320

(1)

The Base Class Method Is Overloaded

321

(1)

The Base Class Method Is private or protected

322

(2)

The Base Class Method Has Default Arguments

324

(1)

The Base Class Method Has a Different Access Level

325

(2)

Copy Constructors and Assignment Operators in Derived Classes

327

(2)

Run-Time Type Facilities

329

(2)

Non-public Inheritance

331

(1)

Virtual Base Classes

331

(1)

Summary

332

(1)

Chapter 11 C++ Quirks, Oddities, And Incidentals

333

(40)

References

334

(9)

Reference Variables

334

(2)

Modifying References

335

(1)

References to Pointers and Pointers to References

336

(1)

Reference Data Members

336

(1)

Reference Parameters

336

(2)

References from Pointers

337

(1)

Pass-by-Reference versus Pass-by-Value

337

(1)

Reference Return Values

338

(1)

Rvalue References

338

(1)

Deciding between References and Pointers

339

(4)

Keyword Confusion

343

(8)

The const Keyword

343

(4)

const Variables and Parameters

343

(2)

const Methods

345

(1)

The constexpr Keyword

346

(1)

The static Keyword

347

(4)

static Data Members and Methods

347

(1)

static Linkage

347

(3)

static Variables in Functions

350

(1)

Order of Initialization of Nonlocal Variables

351

(1)

Order of Destruction of Nonlocal Variables

351

(1)

Types and Casts

351

(11)

Type Aliases

352

(1)

Type Aliases for Function Pointers

353

(2)

Type Aliases for Pointers to Methods and Data Members

355

(1)

typedefs

356

(1)

Casts

357

(6)

const_cast()

357

(1)

static_cast()

358

(1)

reinterpret_ cast()

359

(1)

dynamic_cast()

360

(1)

Summary of Casts

361

(1)

Scope Resolution

362

(1)

Attributes

363

(2)

[ [ noreturn]]

363

(1)

[ [ deprecated]]

364

(1)

[ [ fallthrough]]

364

(1)

[ [ nodiscard]]

364

(1)

[ [ maybe_unused]]

365

(1)

Vendor-Specific Attributes

365

(1)

User-Defined Literals

365

(2)

Standard User-Defined Literals

367

(1)

Header Files

367

(2)

C Utilities

369

(3)

Variable-Length Argument Lists

369

(2)

Accessing the Arguments

370

(1)

Why You Shouldn't Use C-Style Variable-Length Argument Lists

371

(1)

Preprocessor Macros

371

(1)

Summary

372

(1)

Chapter 12 Writing Generic Code With Templates

373

(36)

Overview of Templates

374

(1)

Class Templates

375

(25)

Writing a Class Template

375

(8)

Coding without Templates

375

(3)

A Template Grid Class

378

(4)

Using the Grid Template

382

(1)

Angle Brackets

383

(1)

How the Compiler Processes Templates

383

(1)

Selective Instantiation

384

(1)

Template Requirements on Types

384

(1)

Distributing Template Code between Files

384

(2)

Template Definitions in Header Files

384

(1)

Template Definitions in Source Files

385

(1)

Template Parameters

386

(5)

Non-type Template Parameters

387

(2)

Default Values for Type Parameters

389

(1)

Template Parameter Deduction for Constructors

389

(2)

Method Templates

391

(4)

Method Templates with Non-type Parameters

393

(2)

Class Template Specialization

395

(2)

Deriving from Class Templates

397

(2)

Inheritance versus Specialization

399

(1)

Alias Templates

399

(1)

Function Templates

400

(7)

Function Template Specialization

401

(1)

Function Template Overloading

402

(1)

Function Template Overloading and Specialization Together

403

(1)

Friend Function Templates of Class Templates

403

(1)

Professional Cplusplus 4th edition [Pehme köide]

Konto & seaded

Otsing

Otsingu andmebaas

Filtreeri tulemusi

Teemad Ingliskeelsed raamatud

Vali ostukorv