7.1、7.2、7.3

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
using namespace std;
struct Sales_data
{
    string bookNo;//isbn编号
    unsigned units_sold=;//该书的销量
    double revenue=0.0;//该书的总销售收入
    string isbn()const {return bookNo;}
    Sales_data& combine(const Sales_data &rhs)
    {
        units_sold+=rhs.units_sold;
        revenue+=rhs.revenue;
        return *this;
    }
    double avg_price() const
    {
        if(units_sold)
            return revenue/units_sold;
        else
            ;
    }
};
Sales_data add(const Sales_data& lhs,const Sales_data& rhs)
{
    Sales_data sum=lhs;
    sum.combine(rhs);
    return sum;
}
istream &read(istream &is,Sales_data &item)
{
    ;
    is>>item.bookNo>>item.units_sold>>price;
    item.revenue=item.units_sold*price;
    return is;
}
ostream &print(ostream &os,const Sales_data &item)
{
    os<<item.isbn()<<" "<<item.units_sold<<" "<<item.revenue<<" "<<item.avg_price();
    return os;
}
int main()
{
    Sales_data total;
    if(read(cin,total))
    {
        Sales_data trans;
        while(read(cin,trans))
        {
            if(total.isbn()==trans.isbn())
                total.combine(trans);
            else
            {
                print(cout,total)<<endl;
                total=trans;
            }
        }
        print(cout,total)<<endl;
    }
    else
        cerr<<"No data?"<<endl;
    ;
}

7.4

struct Person
{
    string name,address;
};

7.5

当然应该是const。首先这些成员函数并不修改成员变量,其次为了方便常量调用,所以可以设为const。

struct Person
{
    string name,address;
    string getName()const
    {
        return name;
    }
    string getAddress() const
    {
        return address;
    }
};

7.6、7.7略

7.8

因为read需要写到该变量中,需要修改该对象的值。print函数不需要改值。

7.9

struct Person
{
    string name,address;
    string getName()const
    {
        return name;
    }
    string getAddress() const
    {
        return address;
    }
};
istream &read(istream &is,Person &per)
{
    is>>per.name>>per.address;
    return is;
}
ostream &print(ostream &os,const Person &per)
{
    os<<per.getName()<<" "<<per.getAddress();
    return os;
}
int main()
{
    Person p;
    while(read(cin,p))
        print(cout,p)<<endl;
    ;
}

7.10

成功读取到数据

7.11

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
using namespace std;
struct Sales_data
{
    string bookNo;//isbn编号
    unsigned units_sold=;//该书的销量
    double revenue=0.0;//该书的总销售收入
    Sales_data(),revenue(){}
    string isbn()const {return bookNo;}
    Sales_data& combine(const Sales_data &rhs)
    {
        units_sold+=rhs.units_sold;
        revenue+=rhs.revenue;
        return *this;
    }
    double avg_price() const
    {
        if(units_sold)
            return revenue/units_sold;
        else
            ;
    }
};
Sales_data add(const Sales_data& lhs,const Sales_data& rhs)
{
    Sales_data sum=lhs;
    sum.combine(rhs);
    return sum;
}
istream &read(istream &is,Sales_data &item)
{
    ;
    is>>item.bookNo>>item.units_sold>>price;
    item.revenue=item.units_sold*price;
    return is;
}
ostream &print(ostream &os,const Sales_data &item)
{
    os<<item.isbn()<<" "<<item.units_sold<<" "<<item.revenue<<" "<<item.avg_price();
    return os;
}
int main()
{
    string s;
    cin>>s;
    Sales_data total(s);
    print(cout,total)<<endl;
    ;
}

7.12

这里由于是在类内所以需要提前声明函数,而函数里又有该类,所以需要提前声明该类。

struct Sales_data;
istream &read(istream&,Sales_data&);
struct Sales_data
{
    string bookNo;//isbn编号
    unsigned units_sold=;//该书的销量
    double revenue=0.0;//该书的总销售收入
    Sales_data(),revenue(){}

    Sales_data(istream &is)
    {
        read(is,*this);
    }
    string isbn()const {return bookNo;}
    Sales_data& combine(const Sales_data &rhs)
    {
        units_sold+=rhs.units_sold;
        revenue+=rhs.revenue;
        return *this;
    }
    double avg_price() const
    {
        if(units_sold)
            return revenue/units_sold;
        else
            ;
    }
};
Sales_data add(const Sales_data& lhs,const Sales_data& rhs)
{
    Sales_data sum=lhs;
    sum.combine(rhs);
    return sum;
}
istream &read(istream &is,Sales_data &item)
{
    ;
    is>>item.bookNo>>item.units_sold>>price;
    item.revenue=item.units_sold*price;
    return is;
}
ostream &print(ostream &os,const Sales_data &item)
{
    os<<item.isbn()<<" "<<item.units_sold<<" "<<item.revenue<<" "<<item.avg_price();
    return os;
}
int main()
{
    Sales_data total(cin);
    print(cout,total)<<endl;
    ;
}

7.13

7.14

如果没有初始化某个成员,那么它将用类内初始值初始化。

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
using namespace std;
struct Sales_data;
istream &read(istream&,Sales_data&);
struct Sales_data
{
    string bookNo;//isbn编号
    unsigned units_sold=;//该书的销量
    double revenue=10.0;//该书的总销售收入
    Sales_data() {}
    Sales_data(),revenue() {}

    Sales_data(istream &is)
    {
        read(is,*this);
    }
    string isbn()const
    {
        return bookNo;
    }
    Sales_data& combine(const Sales_data &rhs)
    {
        units_sold+=rhs.units_sold;
        revenue+=rhs.revenue;
        return *this;
    }
    double avg_price() const
    {
        if(units_sold)
            return revenue/units_sold;
        else
            ;
    }
};
Sales_data add(const Sales_data& lhs,const Sales_data& rhs)
{
    Sales_data sum=lhs;
    sum.combine(rhs);
    return sum;
}
istream &read(istream &is,Sales_data &item)
{
    ;
    is>>item.bookNo>>item.units_sold>>price;
    item.revenue=item.units_sold*price;
    return is;
}
ostream &print(ostream &os,const Sales_data &item)
{
    os<<item.isbn()<<" "<<item.units_sold<<" "<<item.revenue<<" "<<item.avg_price();
    return os;
}
int main()
{
    Sales_data total;
    print(cout,total)<<endl;
    ;
}

7.15

struct Person
{
    string name,address;
    Person(string &_name,string &_address):name(_name),address(_address){}
    string getName()const
    {
        return name;
    }
    string getAddress() const
    {
        return address;
    }
};

7.16

在类外允许访问的成员应该在public后面

只允许在类内访问的成员应该在private后面

7.17

struct默认访问权限和继承方式是public

class默认访问权限和继承方式是private

7.18

封装:隐藏对象的属性和实现细节,仅对外开放接口,控制程序中的属性读取和修改的访问级别。

增强安全性和简化编程。

7.19

成员变量name、address应该声明为private,构造函数,getName,getAddress应该声明为public。

7.20

有些类或者函数需要访问该类的非公有成员,可以声明为友元。

好处是实现了访问类内非公有成员

坏处破坏了封装性

7.21

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
using namespace std;
class Sales_data;
istream &read(istream&,Sales_data&);
ostream &print(ostream&,const Sales_data&);
class Sales_data
{
    friend istream &read(istream&,Sales_data&);
    friend ostream &print(ostream&,const Sales_data&);
    //friend Sales_data add(const Sales_data&,const Sales_data&);
private:
    string bookNo;//isbn编号
    unsigned units_sold=;//该书的销量
    double revenue=10.0;//该书的总销售收入
public:
    Sales_data() {}
    Sales_data(),revenue() {}

    Sales_data(istream &is)
    {
        read(is,*this);
    }
    string isbn()const
    {
        return bookNo;
    }
    Sales_data& combine(const Sales_data &rhs)
    {
        units_sold+=rhs.units_sold;
        revenue+=rhs.revenue;
        return *this;
    }
    double avg_price() const
    {
        if(units_sold)
            return revenue/units_sold;
        else
            ;
    }
};
Sales_data add(const Sales_data& lhs,const Sales_data& rhs)
{
    Sales_data sum=lhs;
    sum.combine(rhs);
    return sum;
}
istream &read(istream &is,Sales_data &item)
{
    ;
    is>>item.bookNo>>item.units_sold>>price;
    item.revenue=item.units_sold*price;
    return is;
}
ostream &print(ostream &os,const Sales_data &item)
{
    os<<item.isbn()<<" "<<item.units_sold<<" "<<item.revenue<<" "<<item.avg_price();
    return os;
}
int main()
{
    Sales_data total;
    print(cout,total)<<endl;
    ;
}

7.22

class Person
{
private:
    string name,address;
public:
    Person(string &_name,string &_address):name(_name),address(_address) {}
    string getName()const
    {
        return name;
    }
    string getAddress() const
    {
        return address;
    }
};

7.23

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
using namespace std;
class Screen
{
public:
    typedef std::string::size_type pos;
    Screen()=default;
    Screen(pos ht,pos wd,char c):height(ht),width(wd),contents(ht*wd,c){}
    char get() const
    {
        return contents[cursor];
    }
    inline char get(pos ht,pos wd) const;
    Screen &move(pos r,pos c);
private:
    pos cursor=;
    pos height=,width=;
    string contents;
};
inline Screen &Screen::move(pos r,pos c)
{
    pos row=r*width;
    cursor=row+c;
    return *this;
}
char Screen::get(pos r,pos c) const
{
    return contents[r*width+c];
}

7.24

   Screen()=default;
    Screen(pos ht,pos wd):height(ht),width(wd),contents(ht*wd,' '){}
    Screen(pos ht,pos wd,char c):height(ht),width(wd),contents(ht*wd,c){}

7.25

能。没有涉及一些指针类的操作。

7.26

inline double avg_price() const
    {
        if(units_sold)
            return revenue/units_sold;
        else
            ;
    }

7.27

using namespace std;
class Screen
{
public:
    typedef std::string::size_type pos;
    Screen()=default;
    Screen(pos ht,pos wd):height(ht),width(wd),contents(ht*wd,' ') {}
    Screen(pos ht,pos wd,char c):height(ht),width(wd),contents(ht*wd,c) {}
    char get() const
    {
        return contents[cursor];
    }
    inline char get(pos ht,pos wd) const;
    Screen &move(pos r,pos c);
    Screen &set(char c)
    {
        contents[cursor]=c;
        return *this;
    }
    Screen& display(ostream &os)
    {
        os<<height<<" "<<width<<" "<<contents;
        return *this;
    }
private:
    pos cursor=;
    pos height=,width=;
    string contents;

};
inline Screen &Screen::move(pos r,pos c)
{
    pos row=r*width;
    cursor=row+c;
    return *this;
}
char Screen::get(pos r,pos c) const
{
    return contents[r*width+c];
}
int main()
{
    Screen myScreen(,,'X');
    myScreen.move(,).set('#').display(cout);
    cout<<endl;
    myScreen.display(cout);
    cout<<endl;
    ;
}

输出:

  XXXXXXXXXXXXXXXXXXXX#XXXX
  XXXXXXXXXXXXXXXXXXXX#XXXX

7.28

修改之后的输出:

  XXXXXXXXXXXXXXXXXXXX#XXXX
  XXXXXXXXXXXXXXXXXXXXXXXXX

第一次输出时候的仅仅是原对象的一个副本,不是原来的对象。

所以第二次输出原来的对象,没有改变过。

7.29

7.30

如果有局部变量与成员变量同名会隐藏了该成员变量,所以可以通过this指针显式使用,其他情况下用this与不用都是一样的。

7.31

using namespace std;
class X;
class Y;
class X
{
    Y *py;
};
class Y
{
    X x;
};

声明之后,定义之前,该类是一种不完全类型。不完全类型只能定义指针或引用。

7.32

这个题有点难。

难在程序代码的组织。

第一步声明Screen。因为下面在定义Windows_mgr中,需要用到Screen类,注意没有用到Screen的成员。

第二步定义Windows_mgr同时声明clear但是不能定义clear,因为clear用到了Screen的成员,而此时Screen还未定义。

第三步定义Screen包括对于clear的友元声明,此时clear的声明已经存在

第四步定义clear,此时它才可以使用Screen的成员。

using namespace std;

class Screen;

class Window_mgr
{
public:
    using ScreenIndex=std::vector<Screen>::size_type;
    void clear(ScreenIndex);
private:
    std::vector<Screen> screens ;
};

class Screen
{
    // friend class Window_mgr;
    friend void Window_mgr::clear(ScreenIndex );
public:
    typedef std::string::size_type pos;
    Screen()=default;
    Screen(pos ht,pos wd):height(ht),width(wd),contents(ht*wd,' ') {}
    Screen(pos ht,pos wd,char c):height(ht),width(wd),contents(ht*wd,c) {}
    char get() const
    {
        return contents[cursor];
    }
    inline char get(pos ht,pos wd) const;
    Screen &move(pos r,pos c);
    Screen &set(char c)
    {
        contents[cursor]=c;
        return *this;
    }
    Screen& display(ostream &os)
    {
        os<<height<<" "<<width<<" "<<contents;
        return *this;
    }
private:
    pos cursor=;
    pos height=,width=;
    string contents;
};
inline Screen &Screen::move(pos r,pos c)
{
    pos row=r*width;
    cursor=row+c;
    return *this;
}
char Screen::get(pos r,pos c) const
{
    return contents[r*width+c];
}

void Window_mgr::clear(ScreenIndex i)
{
    Screen &s=screens[i];
    s.contents=string(s.height*s.width,' ');
}

以前写代码都是声明的同时定义,感觉声明了以后隔好远才定义都是自己找麻烦。。这次算是有了新的体会。有时候必须提前声明但是无法定义,必须按一定顺序组织代码。

一个非常重要的地方,声明一个类,在后面定义之前只能用这个类名,而不能使用它的成员,因为编译器不知道它的成员都有谁。

7.33

遇到一个编译器无法识别pos,因为pos它不在类的作用域内。

正确写法:

Screen::pos Screen::size() const
{
    return height*width;
}

7.34

编译错误,pos未定义。

7-35

编译错误。

首先一个错误是在定义setVal的地方,返回值这里的Type是全局的,即string,与类内声明不符,因此会编译错误。

正确写法:Exercise::Type Exercise::setVal(Type parm)
这样返回值就是double。

但是这个代码还是不能通过编译,因为initVal没有定义。由于在函数体内已经进入了类的作用域,所以这里调用的是类的initVal。

下面是我修改以后的代码。

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
using namespace std;

typedef int Type;
Type initVal()
{
    cout<<"use func!"<<endl;
}

class Exercise
{
public:
    typedef double Type;
    Type setVal(Type);
    Type initVal()
    {
        cout<<"use class!"<<endl;
    }
private:
    int val;
};
Exercise::Type Exercise::setVal(Type parm)
{
    //val=parm+::initVal();//这样写就可以调用全局的initVal,注意我把全局的Type换成了int,因为string无法与double相加
    val=parm+initVal();//这样写就可以调用类的initVal
    return val;
}
int main()
{
    Exercise e;
    e.setVal(1.5);
    ;
}

7.36

struct X
{
    X(int i,int j):base(i),rem(base%j) {}
    int rem,base;
};
int main()
{
    X x(,);
    cout<<x.base<<" "<<x.rem<<endl;
    ;
}

成员变量初始化的顺序是与定义时的顺序一致的,因此上面先初始化rem(此时base是未定义的)再初始化base。所以最后结果是违背设计初衷的。

7.37

两个都调用了Sales_data(string s=""):bookNo(s){}

第一个bookNo="",units_sold=0,revenue=0.0.第一个是默认实参初始化,后两个是类内初始值

第二个bookNo="9-999-99999-9",unit_sold=0,revenue=0.0,第一个是直接初始化,后两个是类内初始值

7.38

    Sales_data(istream &is=cin)
    {
        read(is,*this);
    }

但此时不能在显式定义无参构造函数,因为两者会产生二义性调用。

7.39

不合法。二义性调用。

7.40

7.41

#include<iostream>
#include<cstdio>
#include<vector>
#include<string>
using namespace std;
class Sales_data;
istream &read(istream&,Sales_data&);
ostream &print(ostream&,const Sales_data&);
class Sales_data
{
    friend istream &read(istream&,Sales_data&);
    friend ostream &print(ostream&,const Sales_data&);
    //friend Sales_data add(const Sales_data&,const Sales_data&);
private:
    string bookNo;//isbn编号
    unsigned units_sold=;//该书的销量
    double revenue=10.0;//该书的总销售收入
public:
    Sales_data():Sales_data(,)
    {
        cout<<"我是无参构造函数!"<<endl;
    }
    Sales_data(const string &s,unsigned cnt,double price):bookNo(s),units_sold(cnt),revenue(cnt*price)
    {
        cout<<"我是三参构造函数!"<<endl;
    }
    Sales_data(,)
    {
        cout<<"我是一参构造函数!"<<endl;
    }
    Sales_data(istream &is):Sales_data()
    {
        cout<<"我是istream构造函数!"<<endl;
        read(is,*this);
    }
    string isbn()const
    {
        return bookNo;
    }
    Sales_data& combine(const Sales_data &rhs)
    {
        units_sold+=rhs.units_sold;
        revenue+=rhs.revenue;
        return *this;
    }
    double avg_price() const
    {
        if(units_sold)
            return revenue/units_sold;
        else
            ;
    }
};
Sales_data add(const Sales_data& lhs,const Sales_data& rhs)
{
    Sales_data sum=lhs;
    sum.combine(rhs);
    return sum;
}
istream &read(istream &is,Sales_data &item)
{
    ;
    is>>item.bookNo>>item.units_sold>>price;
    item.revenue=item.units_sold*price;
    return is;
}
ostream &print(ostream &os,const Sales_data &item)
{
    os<<item.isbn()<<" "<<item.units_sold<<" "<<item.revenue<<" "<<item.avg_price();
    return os;
}
int main()
{
    Sales_data a;
    Sales_data b(");
    Sales_data c(cin);
    ;
}

先执行委托的构造函数。

7.42

7.43

以下代码是不能通过编译的。因为C的默认构造函数会调用一个无参的Nodefault的构造函数,而它是不存在的。

using namespace std;
class Nodefault
{
public:

    Nodefault(int x) {}
};
class C
{
private:
    Nodefault nd;
public:
    C()=default;
};
int main()
{
    C c;
    ;
}

7.44

编译错误,缺少Nodefault的无参构造函数。

7.45

不合法,缺少Nodefault的无参构造函数。

7.46

(a)是的

(b)不是。也可能是有参数但是还有默认实参的构造函数。

(c)不对。默认构造函数是编译器自己合成的。即使该类没有成员变量,它依旧会被提供。

(d)是的。

7.47

可以吧?

7.48

如果只有Sales_data(const string &s);这一个函数的话,似乎不受影响。

7.49

(a)string隐式转化成Sales_data,要求该构造函数Sales_data(const string &s)不是explicit的

(b)无法通过编译。不懂?因为临时变量不能被绑定到普通引用上?

(c)string隐式转化成Sales_data&,要求该构造函数Sales_data(const string &s)不是explicit的

7.50

似乎都可以

7.51

string s="sfds"这样是合法的

但是vector<int> vec=10;这样缺少违背了设计初衷的。

7.52

这样初始化方法只有聚合类才支持。

而64页的该类由于提供了类内初始值因此不是聚合类。

正确写法

using namespace std;
struct Sales_data
{
    string bookNo;//isbn编号
    unsigned units_sold;//该书的销量
    double revenue;//该书的总销售收入
};
int main()
{

    Sales_data total={,34.567};
    ;
}

7.53

7.54

不能。constexpr 的成员函数是隐身const,不能修改成员变量。

7.55

没有constexpr 构造函数?

7.56

所有类的对象共享的成员称为类的静态成员。

普通成员,类的每个对象独占一份。

7.57

7.58

不能在类内初始化静态成员,const静态成员除外。

正确写法

class Example
{
public:
    static double rate;
    ;
    static vector<double> vec;
};
;
vector<double> Example::vec(vecSize);

《C++primer》v5 第7章 类 读书笔记 习题答案的更多相关文章

  1. 《C++primer》v5 第1章 开始 读书笔记 习题答案

    从今天开始在博客里写C++primer的文字.主要以后面的习题作业为主,会有必要的知识点补充. 本人也是菜鸟,可能有不对之处,还望指出. 前期内容可能会比较水. 1.1略 1.2略 1.3 cin和c ...

  2. 《C++primer》v5 第6章 函数 读书笔记 习题答案

    6.1 实参是在函数调用处填写的参数.形参是在函数体使用的参数. 实参是形参的初始值. 具体参见:http://blog.163.com/zhengguo_li/blog/static/7030148 ...

  3. 《C++primer》v5 第5章 语句 读书笔记 习题答案

    5.1 空语句只有一个";".如果什么也不想做可以使用空语句. 5.2 用花括号{}括起来的叫块,也叫复合语句.有多条语句作用在同一个作用域时,需要用花括号括起来. 5.3 降低了 ...

  4. 《C++primer》v5 第4章 表达式 读书笔记 习题答案

    4.1 105 4.2 *vec.begin()=*(vec.begin())//先调用点运算符,再解引用 *vec.begin()+1=(*vec.begin())+1//先解引用,再加一 4.3略 ...

  5. 《C++primer》v5 第3章 字符串、向量和数组 读书笔记 习题答案

    本章问题 1.char *p="hello world";与char p[]="hello world"的问题. 简单说前者是一个指向字符串常量的指针,后者是一 ...

  6. 《C++primer》v5 第8章 IO库 读书笔记 习题答案

    8.1.8.2 这一章不咋会啊.. istream &read(istream &is) { int a; auto old_state=is.rdstate(); is.clear( ...

  7. 《C++primer》v5 第2章 变量和基本类型 读书笔记 习题答案

    2.1 int,long long ,short 可表示范围和占用内存空间不同.具体与计算机有关. 无符号类型只能表示0和正数,带符号类型可以表示负数,0,正数. float是单精度,一般占用4个字节 ...

  8. C++primer(第五版)读书笔记&习题解答---CHAPTER 3

    C++标准库类型包括:string,vector和迭代器,其中string是可变长的字符序列,vector存放的是某种给定类型对象的可变长序列,迭代器是string和vector的配套类型,常被用于访 ...

  9. C++ Primer(第五版)读书笔记 & 习题解答 --- Chapter 3

    Chapter 3.1 1. using声明具有如下的形式: using namespace::name; Chapter 3.2 1. C++标准一方面对库类型所提供的操作做了规定,另一方面也对库的 ...

随机推荐

  1. Michael Schatz - 序列比对课程

    Michael Schatz - Cold Spring Harbor Laboratory 最近在研究 BWA mem 序列比对算法,直接去看论文,看不懂,论文就3页,太精简了,好多背景知识都不了解 ...

  2. [分享] 封装工具ES4配置文件解释

    [分享] 封装工具ES4配置文件解释 LiQiang 发表于 2015-2-3 14:41:21 https://www.itsk.com/thread-346132-1-4.html [分享] 封装 ...

  3. C# GDI+发生一般性错误(A generic error occurred in GDI+))

    解决思路: 1. 因为 .net GDI+ 是对底层 的封装. 所以可以尝试用 Marshal.GetLastWin32Error();函数获得底层错误代码. try{ image.Save(file ...

  4. 简述linux的发行版,并描述不同发行版之间的联系与区别

    bash命令行返回值和展开 标签(空格分隔): bash,命令,状态,展开 1.命令状态结果和执行结果 (1)命令执行的状态返回值,命令执行完成之后,其执行状态结果值保存于bash的特殊状态变量$?中 ...

  5. Git代码管理常用命令

    1) 远程仓库相关命令 检出仓库:$ git clone git://github.com/jquery/jquery.git查看远程仓库:$ git remote -v添加远程仓库:$ git re ...

  6. Android studio下gradle Robolectric单元测试配置

    android studio下gradle Robolectric单元测试配置 1.Robolectric Robolectric是一个基于junit之上的单元测试框架.它并不依赖于Android提供 ...

  7. 学jQuery Mobile后的感想

    jQuery Mobile是jQuery 在手机上和平板设备上的版本.jQuery Mobile 不仅会给主流移动平台带来jQuery核心库,而且会发布一个完整统一的jQuery移动UI框架.支持全球 ...

  8. 使用VS2012调试ReactOS源码

    目录 一 下载并安装VS2012 二 下载并安装WDK80 三 下载ReactOS0315源码 四 下载并安装RosBE211 五 用RosBE命令行编译ReactOS源码 六 用VS2012编译nt ...

  9. 跟小静读《jQuery权威指南》——目录

    前言 2014年开始了,年底给自己制订的学习计划,第一步先从学习<jQuery权威指南>开始. jQuery大家都很比较熟悉,但是我经常是边用的时候边对照着API,这次找本书通读一遍,记录 ...

  10. 学习iOS【3】数组、词典和集合

    一.数组 1.不可变数组NSArray arrayWithObjects:使用一组对象作为元素创建不可变数组,注意数组的最后一个值需要指定为nil,用来表示参数的结束,但是nil并不会存储在数组中. ...