C++快速入门——国外大神的教程.pdf

C+is a systems programming language that,according to its inventor Bjarne Stroustrup,was designed tobe a better Csupport data abstractionsupport object-oriented programmingsupport generic programmingThough its syntax can be more difficult or complex than newer languages,it is widely used because it compiles to native instructions that can be directly run by the processor and offers tight control over hardware(like C)while offering high-level features such as generics,exceptions,and classes.This combination of speed and functionality makes C+one of the most widely-used programming languages./Comparison to C/C+is _almost_ a superset of C and shares its basic syntax for/variable declarations,primitive types,and functions./Just like in C,your programs entry point is a function called/main with an integer return type./This value serves as the programs exit status./See http:/en.wikipedia.org/wiki/Exit_status for more information.int main(int argc,char*argv)/Command line arguments are passed in by argc and argv in the same way /they are in C./argc indicates the number of arguments,/and argv is an array of C-style strings(char*)/representing the arguments./The first argument is the name by which the program was called./argc and argv can be omitted if you do not care about arguments,/giving the function signature of int main()/An exit status of 0 indicates success.return 0;/However,C+varies in some of the following ways:/In C+,character literals are charssizeof(c)=sizeof(char)=1/In C,character literals are intssizeof(c)=sizeof(int)/C+has strict prototypingvoid func();/function which accepts no arguments/In Cvoid func();/function which may accept any number of arguments/Use nullptr instead of NULL in C+int*ip=nullptr;/C standard headers are available in C+,/but are prefixed with c and have no.h suffix.#include int main()printf(Hello,world!n);return 0;/Function overloading/C+supports function overloading/provided each function takes different parameters.void print(char const*myString)printf(String%sn,myString);void print(int myInt)printf(My int is%d,myInt);int main()print(Hello);/Resolves to void print(const char*)print(15);/Resolves to void print(int)/Default function arguments/You can provide default arguments for a function/if they are not provided by the caller.void doSomethingWithInts(int a=1,int b=4)/Do something with the ints hereint main()doSomethingWithInts();/a=1,b=4 doSomethingWithInts(20);/a=20,b=4 doSomethingWithInts(20,5);/a=20,b=5/Default arguments must be at the end of the arguments list.void invalidDeclaration(int a=1,int b)/Error!/Namespaces/Namespaces provide separate scopes for variable,function,/and other declarations./Namespaces can be nested.namespace First namespace Nested void foo()printf(This is First:Nested:foon);/end namespace Nested/end namespace Firstnamespace Second void foo()printf(This is Second:foon);void foo()printf(This is global foon);int main()/Includes all symbols from namespace Second into the current scope.Note /that simply foo()no longer works,since it is now ambiguous whether /were calling the foo in namespace Second or the top level.using namespace Second;Second:foo();/prints This is Second:foo First:Nested:foo();/prints This is First:Nested:foo :foo();/prints This is global foo/Input/Output/C+input and output uses streams/cin,cout,and cerr represent stdin,stdout,and stderr./is the extraction operator.#include /Include for I/O streamsusing namespace std;/Streams are in the std namespace(standard library)int main()int myInt;/Prints to stdout(or terminal/screen)cout myInt;/cout can also be formatted cout Your favorite number is myInt n;/prints Your favorite number is cerr Used for error messages;/Strings/Strings in C+are objects and have many member functions#include using namespace std;/Strings are also in the namespace std(standard library)string myString=Hello;string myOtherString=World;/+is used for concatenation.cout myString+myOtherString;/Hello Worldcout myString+You;/Hello You/C+strings are mutable and have value semantics.myString.append(Dog);cout myString;/Hello Dog/References/In addition to pointers like the ones in C,/C+has _references_./These are pointer types that cannot be reassigned once set/and cannot be null./They also have the same syntax as the variable itself:/No*is needed for dereferencing and/&(address of)is not used for assignment.using namespace std;string foo=I am foo;string bar=I am bar;string&fooRef=foo;/This creates a reference to foo.fooRef+=.Hi!;/Modifies foo through the referencecout fooRef;/Prints I am foo.Hi!/Doesnt reassign fooRef.This is the same as foo=bar,and/foo=I am bar/after this line.cout&fooRef endl;/Prints the address of foofooRef=bar;cout&fooRef endl;/Still prints the address of foocout fooRef;/Prints I am bar/The address of fooRef remains the same,i.e.it is still referring to foo.const string&barRef=bar;/Create a const reference to bar./Like C,const values(and pointers and references)cannot be modified.barRef+=.Hi!;/Error,const references cannot be modified./Sidetrack:Before we talk more about references,we must introduce a concept/called a temporary object.Suppose we have the following code:string tempObjectFun().string retVal=tempObjectFun();/What happens in the second line is actually:/-a string object is returned from tempObjectFun/-a new string is constructed with the returned object as argument to the/constructor/-the returned object is destroyed/The returned object is called a temporary object.Temporary objects are/created whenever a function returns an object,and they are destroyed at the/end of the evaluation of the enclosing expression(Well,this is what the/standard says,but compilers are allowed to change this behavior.Look up/return value optimization if youre into this kind of details).So in this/code:foo(bar(tempObjectFun()/assuming foo and bar exist,the object returned from tempObjectFun is/passed to bar,and it is destroyed before foo is called./Now back to references.The exception to the at the end of the enclosing/expression rule is if a temporary object is bound to a const reference,in/which case its life gets extended to the current scope:void constReferenceTempObjectFun()/constRef gets the temporary object,and it is valid until the end of this /function.const string&constRef=tempObjectFun();./Another kind of reference introduced in C+11 is specifically for temporary/objects.You cannot have a variable of its type,but it takes precedence in/overload resolution:void someFun(string&s)./Regular referencevoid someFun(string&s)./Reference to temporary objectstring foo;someFun(foo);/Calls the version with regular referencesomeFun(tempObjectFun();/Calls the version with temporary reference/For example,you will see these two versions of constructors for/std:basic_string:basic_string(const basic_string&other);basic_string(basic_string&other);/Idea being if we are constructing a new string from a temporary object(which/is going to be destroyed soon anyway),we can have a more efficient/constructor that salvages parts of that temporary string.You will see this/concept referred to as move semantics./Enums/Enums are a way to assign a value to a constant most commonly used for/easier visualization and reading of codeenum ECarTypes Sedan,Hatchback,SUV,Wagon;ECarTypes GetPreferredCarType()return ECarTypes:Hatchback;/As of C+11 there is an easy way to assign a type to the enum which can be/useful in serialization of data and converting enums back-and-forth between/the desired type and their respective constantsenum ECarTypes:uint8_t Sedan,/0 Hatchback,/1 SUV=254,/254 Hybrid/255;void WriteByteToFile(uint8_t InputValue)/Serialize the InputValue to a filevoid WritePreferredCarTypeToFile(ECarTypes InputCarType)/The enum is implicitly converted to a uint8_t due to its declared enum type WriteByteToFile(InputCarType);/On the other hand you may not want enums to be accidentally cast to an integer/type or to other enums so it is instead possible to create an enum class which/wont be implicitly convertedenum class ECarTypes:uint8_t Sedan,/0 Hatchback,/1 SUV=254,/254 Hybrid/255;void WriteByteToFile(uint8_t InputValue)/Serialize the InputValue to a filevoid WritePreferredCarTypeToFile(ECarTypes InputCarType)/Wont compile even though ECarTypes is a uint8_t due to the enum /being declared as an enum class!WriteByteToFile(InputCarType);/Classes and object-oriented programming/First example of classes#include/Declare a class./Classes are usually declared in header(.h or.hpp)files.class Dog /Member variables and functions are private by default.std:string name;int weight;/All members following this are public/until private:or protected:is found.public:/Default constructor Dog();/Member function declarations(implementations to follow)/Note that we use std:string here instead of placing /using namespace std;/above./Never put a using namespace statement in a header.void setName(const std:string&dogsName);void setWeight(int dogsWeight);/Functions that do not modify the state of the object /should be marked as const./This allows you to call them if given a const reference to the object./Also note the functions must be explicitly declared as _virtual_ /in order to be overridden in derived classes./Functions are not virtual by default for performance reasons.virtual void print()const;/Functions can also be defined inside the class body./Functions defined as such are automatically inlined.void bark()const std:cout name barks!n;/Along with constructors,C+provides destructors./These are called when an object is deleted or falls out of scope./This enables powerful paradigms such as RAII /(see below)/The destructor should be virtual if a class is to be derived from;/if it is not virtual,then the derived class destructor will /not be called if the object is destroyed through a base-class reference /or pointer.virtual Dog();/A semicolon must follow the class definition./Class member functions are usually implemented in.cpp files.Dog:Dog()std:cout A dog has been constructedn;/Objects(such as strings)should be passed by reference/if you are modifying them or const reference if you are not.void Dog:setName(const std:string&dogsName)name=dogsName;void Dog:setWeight(int dogsWeight)weight=dogsWeight;/Notice that virtual is only needed in the declaration,not the definition.void Dog:print()const std:cout Dog is name and weighs weight kgn;Dog:Dog()cout Goodbye name n;int main()Dog myDog;/prints A dog has been constructed myDog.setName(Barkley);myDog.setWeight(10);myDog.print();/prints Dog is Barkley and weighs 10 kg return 0;/prints Goodbye Barkley/Inheritance:/This class inherits everything public and protected from the Dog class/as well as private but may not directly access private members/methods/without a public or protected method for doing soclass OwnedDog:public Dog void setOwner(const std:string&dogsOwner);/Override the behavior of the print function for all OwnedDogs.See /http:/en.wikipedia.org/wiki/Polymorphism_(computer_science)#Subtyping /for a more general introduction if you are unfamiliar with /subtype polymorphism./The override keyword is optional but makes sure you are actually /overriding the method in a base class.void print()const override;private:std:string owner;/Meanwhile,in the corresponding.cpp file:void OwnedDog:setOwner(const std:string&dogsOwner)owner=dogsOwner;void OwnedDog:print()const Dog:print();/Call the print function in the base Dog class std:cout Dog is owned by owner n;/Prints Dog is and weights /Dog is owned by/Initialization and Operator Overloading/In C+you can overload the behavior of operators such as+,-,*,/,etc./This is done by defining a function which is called/whenever the operator is used.#include using namespace std;class Point public:/Member variables can be given default values in this manner.double x=0;double y=0;/Define a default constructor which does nothing /but initialize the Point to the default value(0,0)Point();/The following syntax is known as an initialization list /and is the proper way to initialize class member values Point(double a,double b):x(a),y(b)/*Do nothing except initialize the values*/Overload the+operator.Point operator+(const Point&rhs)const;/Overload the+=operator Point&operator+=(const Point&rhs);/It would also make sense to add the-and-=operators,/but we will skip those for brevity.;Point Point:operator+(const Point&rhs)const /Create a new point that is the sum of this one and rhs.return Point(x+rhs.x,y+rhs.y);Point&Point:operator+=(const Point&rhs)x+=rhs.x;y+=rhs.y;return*this;int main()Point up(0,1);Point right(1,0);/This calls the Point+operator /Point up calls the+(function)with right as its parameter Point result=up+right;/Prints Result is upright(1,1)cout Result is upright(result.x ,result.y )n;return 0;/Templates/Templates in C+are mostly used for generic programming,though they are/much more powerful than generic constructs in other languages.They also/support explicit and partial specialization and functional-style type/classes;in fact,they are a Turing-complete functional language embedded/in C+!/We start with the kind of generic programming you might be familiar with.To/define a class or function that takes a type parameter:templateclass Box public:/In this class,T can be used as any other type.void insert(const T&).;/During compilation,the compiler actually generates copies of each template/with parameters substituted,so the full definition of the class must be/present at each invocation.This is why you will see template classes defined/entirely in header files./To instantiate a template class on the stack:Box intBox;/and you can use it as you would expect:intBox.insert(123);/You can,of course,nest templates:BoxBox boxOfBox;boxOfBox.insert(intBox);/Until C+11,you had to place a space between the two s,otherwise/would be parsed as the right shift operator./You will sometimes see/template/instead.The class keyword and typename keywords are _mostly_/interchangeable in this case.For the full explanation,see/http:/en.wikipedia.org/wiki/Typename/(yes,that keyword has its own Wikipedia page)./Similarly,a template function:templatevoid barkThreeTimes(const T&input)input.bark();input.bark();input.bark();/Notice that nothing is specified about the type parameters here.The compiler/will generate and then type-check every invocation of the template,so the/above function works with any type T that has a const bark method!Dog fluffy;fluffy.setName(Fluffy)barkThreeTimes(fluffy);/Prints Fluffy barks three times./Template parameters dont have to be classes:templatevoid printMessage()cout Learn C+in Y minutes!endl;/And you can explicitly specialize templates for more efficient code.Of/course,most real-world uses of specialization are not as trivial as this./Note that you still need to declare the function(or class)as a template/even if you explicitly specified all parameters.templatevoid printMessage()cout Learn C+faster in only 10 minutes!endl;printMessage();/Prints Learn C+in 20 minutes!printMessage(