qq_31248551的博客

#include // 这个是C语言的编写，#include class Book{ // 类的成员，数据成员，成员函数，};int main(){ int a; // int 是整形类型，a 是叫做变量， Book b; // Book 是类，b是对象， system("pause"); // 这个是暂停键， return 0;}

#ifndef TEST_H_#define TEST_H_namespace ThinkingInCppDemoLib // 这个就是一个名称空间，ThinkingInCppDemoLib这个是名称空间的名字， // 在这里使用名称空间，为了避免在其它的人编写时使用相同的类 class f 类，{ class t // 这个类在名称空间里，这个地方也可以是全局函数\变量名称、全局

#include #include using namespace std;class A{public: virtual int f() const { cout << "A::f()" << endl; return 1; } virtual void f(string) const {} virtual void g() const {}};class B

#include #include using namespace std;enum note{ middleC, Csharp, Eflat};class Instument // 这个是一个纯抽象类因为它所有的抽象函数都是纯虚函数，只有一个纯虚函数就是普通的抽象类，不能用来创建对象可以用来做接口，{public: virtual void play(note) c

#pragma oncenamespace demo2 { using namespace System; using namespace System::ComponentModel; using namespace System::Collections; using namespace System::Windows::Forms; using namespace Syste

#ifndef TIME_H_#define TIME_H_#include class Time{ std::time_t t; // time_t是时间的起始时间， std::tm local; // tm 就是时间的记录， char asciiRep[26]; unsigned char lflag, aflag; // 这个就是为了做标记， void updat

#include using namespace std;enum note{ middleC, Csharp, Cflat};class Instrument{public: void play(note) const {}};class Flute : public Instrument{};void tune(Instrument& i){ i.pl

#include using namespace std;class Y{private: int i;public: Y(){} Y(int ii) : i(ii) {}};class X : public Y // 这个是继承，在继承的时候，X 类中含有的函数与Y 函数相同，则将Y类的此函数屏蔽掉，无论参数是否相同，只要函数一样就将其屏蔽掉，{private:

#ifndef COS_H_#define COS_H_#include #include #include inline void require(bool requirement, const std::string& msg = "Requirement failed"){ if (!requirement) { fputs(msg.c_str(), stderr);

#ifndef ACCOUNT_H_#define ACCOUNT_H_#include class Account{public: Account(std::string name, double money); double getAccount() const; void deposit(double money); void applyint(); static

# include using namespace std;class Egg // 这个就是单例模式，只有一个对象，单例设计模式{private: static Egg e; // 只有这么一个对象， int i; Egg(int ii) : i(ii){} Egg(const Egg&); // 这个做成私有的防止copy 构造函数，public: static E

#include #include #include using namespace std;templateclass Stack{private: T stack[ssize]; int top;public: Stack() : top(0){} void push(const T& i) { if (top <ssize)// 这个是判断条件， s

#include using namespace std;class IntStack{private: enum {ssize = 100}; int stack[ssize]; int top;public: IntStack() : top(0){} //~IntStack(){} void push(int i) { if (top <ssize)// 这个

#include using namespace std;class IntStack{private: enum {ssize = 100}; int stack[ssize]; int top;public: IntStack() : top(0){} //~IntStack(){} void push(int i) { if (top <ssize)// 这个

#ifndef STASH_H #define STASH_H #include namespace ThinkingInCppDemoLib{ template class PStash { private: int quantity; int next; T** storage; void inflate(int increase = incr);

#include #include using namespace std;// template 这就是模板，template // 这个就是模板中的常量，class Array{private: //enum { size = 100 }; int A[size];public: T& operator[](T& index) { index > 0 &&

#include using namespace std;class Matrix; // 前置声明，class Scalar;class Vector;class Math{public: virtual Math& operator*(Math& rv) = 0; // 虚的运算符重载， virtual Math& multiply(Matrix*) = 0;

#include using namespace std;class Y{private: int i;public: Y(){} Y(int ii) : i(ii) {}};class X : public Y // 这个是继承，在继承的时候，X 类中含有的函数与Y 函数相同，则将Y类的此函数屏蔽掉，无论参数是否相同，只要函数一样就将其屏蔽掉， {priva

#ifndef ACCOUNT_H_#define ACCOUNT_H_#ifdef __cplusplus // 下边的设计就是无论是C 或者 C++ 都可以直接的调用，只需要加上此头文件就可以，extern "C"{#endiffloat f(int a, int b);void p();void t();#ifdef __cplusplus}#endif

#include using namespace std;class X{private: int i;public: X() { i = 0; // 这个只是初始化， } void set(int ii) { i = ii; } int read() const { return i; } int permute() { return i *

#include using namespace std;#define SRUARE (x) (x)*(x) // 这个是C语言的预定义宏，是计算x*x的，它有缺点。总是出错，inline double square(double x) // 在函数前边加上inline就是内联函数，内联函数在编译的时候执行，{ double result; result = x * x;

#include using namespace std;const int sz = 20;class Pointer;class Holder{private: int a[sz];public: Holder(); ~Holder(); friend class Pointer;};Holder::~Holder(){ }class Point

#ifndef TEST_H_#define TEST_H_class Demo{private: class Cheshire; // 将私有的成员隐藏在Cheshire里边.这个就是句柄类把private部分隐藏起来，还可以减少重复编译。 Cheshire* smile;public: void initialize(); int read(); void change(

#include using namespace std;const int sz = 20;class Pointer;class Holder{private: int a[sz];public: void initialize(); friend class Pointer;};class Pointer{private: Holder* h; i

class Stash{ int size; int quantity; int next; unsigned char* storage;public: void initialize(int size); int add(const void* element); void inflate(int increase); int count(); // 计算Stash里的数

typedef struct CStashTag{ int size; int quantity; int next; unsigned char* storage;}CStash;void initialize(CStash* s, int size);int add(CStash* s, const void* element);void inflate(CStash* s

#include using namespace std;class Dog{public: int a;};class Cat{public: int c;};class Person{public: Cat operator+(const Dog& d) // 这个就是成员函数重载， { Cat cat; cat.c = b + d.a;

#include #include using namespace std;class Person{public: Person(std::string st, int a, double ht) : name(st), age(a), height(ht) { cout << " normal constructor" << endl; } Person(const

#include using namespace std;int x = 12;int y = 80;int *p = &y; // & 就是引用，int &r = y; // 引用就是别名相当于y 又有了一个别名r，r 和 y 是同一个变量，对r 进行操作就是对y 进行操作，// 创建引用的时候必须初始化，引用不能改变、也没有NULL引用，// 指针可以在任何时候初始化，指针

#ifndef BYTE_H#define BYTE_H#include class Byte{ unsigned char b;public: Byte(unsigned char bb = 0) : b(bb){} void print() const { std::cout << (int)b << std::endl; } const Byte& opera

#ifndef SUPERVAR_H_#define SUPERVAR_H_class SuperVar { enum // 枚举 后边的标识符可以不写即为匿名的， { character, integer, floating_point }varType; // 这里的varType 是class的成员变量， union // 这个就是使

#include using namespace std;class Dog{private: const volatile unsigned char byte; // volatile 可以通过外部接口修改byte， volatile unsigned char flag; // volatile是限定符，可以用数据成员，成员函数和对象本身使用volatile， enum {

#include using namespace std;class Dog{private: int x; const int y; // 在这里不能进行初始化，只有静态的const才能进行初始化。在运行时分配内存，初始化列表进行初始化， static const int z = 200; // 这个是静态的const数据成员，是共有的，这个是可读的不能够进行修改了。这个是编

#ifndef STASH_H#define STASH_H#include namespace ThinkingInCppDemoLib{ class PStash { private: int quantity; int next; void ** storage; void inflate(int increase); public: PStash()

#include #include using namespace std;class Circle{private: int r;public: Circle(){} ~Circle(){} Circle(int rr) :r(rr){} void print() { cout << "r = " << r << endl; }};Circle *pCir

#include #include using namespace std;class Dog{private: string nm; int refcount; // 引用计数， Dog(const string& name) : nm(name), refcount(1) { cout << "Creating Dog: " << *this << endl; }

#include #include using namespace std;class Dog{private: string nm;public: Dog(const string& name) : nm(name) { cout << "Creating Dog: " << *this << endl; } ~Dog() { cout << "Deleti

#include using namespace std;class Dog{private: int k;public: // C++自动创建赋值运算符， Dog(int kk) : k(kk) { cout << "这是构造函数，" << endl; } Dog(const Dog& dog) : k(dog.k) { cout << "这里是拷贝构造函数。"

#include using namespace std;const int ArSize = 80;char* left(const char* str, int n = 2); // 提取字符串str里边左边n 个，void f(int a, int b, float c); // 函数中声明的变量x y z 可以跟函数定义中的变量不一样，函数声明的变量也可以不写，int

#include using namespace std;template // 这个就是函数模板，void Swap(T &a, T &b) // C++里边已经有一个swap了，里边的s就是小写，参数a b 前面必须要用引号，{ T temp; temp = b; b = a; a = temp;}int main(){ int a(2), b(8); S