2.9字符专题

2.9.1类型同义词

也就是typedef声明，这个东西就是相当于起绰号，为了方便记忆和简化而生。相信在学习其他语言的时候一定有所了解，在此不再赘述。

再次示例一个之前写过的用typedef改写的程序：

/*************************************************************************
    > File Name: char_count.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年05月24日 星期六 21时15分10秒
 ************************************************************************/

#include <iomanip>
#include <ios>
#include<iostream>
#include<string>
#include <map>

using namespace std;

//Counting Words, Restricting Words to Letters and Letter-like Characters

int main()
{
    typedef map<string, int>    count_map;
    typedef count_map::iterator count_iter;
    typedef string::size_type   str_size;

    count_map counts;
    string word;

    // Read words from the standard input and count the number of times
    // each word occurs.
    string okay("ABCDEFGHIJKLMNOPQRSTUVWXYZ"
              "abcdefghijklmnopqrstuvwxyz"
              "0123456789-_");

    while (cin >> word)
    {
        // Make a copy of word, keeping only the characters that appear in okay.
        string copy;
        for (string::iterator w(word.begin()); w != word.end(); ++w)
        if (okay.find(*w) != string::npos)
            copy.push_back(*w);
        // The "word" might be all punctuation, so the copy would be empty.
        // Don't count empty strings.
        if (not copy.empty())
        ++counts[copy];
    }

    // Determine the longest word.
    str_size longest(0);
    for (count_iter iter(counts.begin()); iter != counts.end(); ++iter)
        if (iter->first.size() > longest)
        longest = iter->first.size();

    // For each word/count pair...
    const int count_size(10); // Number of places for printing the count
    for (count_iter iter(counts.begin()); iter != counts.end(); ++iter)
        // Print the word, count, newline. Keep the columns neatly aligned.
        cout << setw(longest)    << left << iter->first <<
                setw(count_size) << right << iter->second << '\n';
    return 0;
}

2.9.2字符

字符I/O

get函数一次读取一个字符，且不会对空白字符做特殊处理。也可以使用标准输入操作符实现同样的效果，但是必须同时使用std::skipws操作子。恢复默认行为的时候使用std::skipws操作子。

程序示例:

/*************************************************************************
    > File Name: char_io.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年05月24日 星期六 16时29分46秒
 ************************************************************************/

#include<ios>
#include<iostream>
#include<string>

using namespace std;

// 下面代码中的get函数和noskipws操作子具体作用请自行查阅资料吧。
// 其实就是为了处理空白字符。
int main()
{
    // cin >> noskipws;
    char ch;
    while(cin.get(ch))
        cout << ch;
    return 0;
}

结果如下：

现在进行一个小练习，假设程序需要读入一系列的点。分别用x，y坐标定义，并以逗号隔开。在每个数字前面、后面以及逗号周围允许有空白。将点分别读入保存x值的向量和保存y的向量，如果点后面没有正确的逗号则结束输入循环。打印向量的内容，每行一个点。

示例代码：

/*************************************************************************
    > File Name: char_exc.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年05月24日 星期六 16时41分56秒
 ************************************************************************/

#include <algorithm>
#include<iostream>
#include<string>
#include <limits>
#include <vector>

using namespace std;

int main()
{
    typedef vector<int> intvec;
    typedef intvec::iterator iterator;

    intvec xs, ys;        // store the xs and ys

    {
        // local block to keep I/O variables local
        int x(0), y(0);      // variables for I/O
        char sep(' ');
        // Loop while the input stream has an integer (x), a character (sep),
        // and another integer (y); then test that the separator is a comma.
        // 当读入的分隔符不是逗号的时候，结束输入，开始输出
        while (cin >> x >> sep and sep == ',' and cin >> y)
        {
            xs.push_back(x);
            ys.push_back(y);
        }
    }
    cout << "The data you input are: " << endl;
    for (iterator x(xs.begin()), y(ys.begin()); x != xs.end(); ++x, ++y)
        std::cout << *x << ',' << *y << '\n';
    return 0;
}

结果如下：

转义字符

再次仅仅贴一下几个常用的转义字符，具体转义字符用法什么的，请自行查阅资料吧，这个真真的是最基础的编程语言知识。

字符本地化

说到字符我们必然想到不同的国家的字符不同，英语有26个字母，但是德国法国等国家还有其他的一些字符，比如下面图的那些字符，我们要如何处理呢，好在C++提供了一个函数，可以告知我们那些字符是一个字母，：

下面示例一个程序，使用isalnum来替代调用find函数：

/*************************************************************************
    > File Name: char_isalnum.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年05月26日 星期日 10时13分27秒
 ************************************************************************/

/** Testing a Character by Calling isalnum  */
#include <iostream>
#include <istream>
#include <locale>
#include <map>
#include <ostream>
#include <string>

int main()
{
    using namespace std;
    typedef map<string, int>    count_map;
    typedef count_map::iterator count_iter;

    count_map counts;
    string word;

    // Read words from the standard input and count the number of times
    // each word occurs.
    while (cin >> word)
    {
        // Make a copy of word, keeping only alphabetic characters.
        string copy;
        for (string::iterator w(word.begin()); w != word.end(); ++w)
       if (isalnum(*w, locale("")))
            copy.push_back(*w);
        // The "word" might be all punctuation, so the copy would be empty.
        // Don't count empty strings.
        if (not copy.empty())
        ++counts[copy];
    }

    // For each word/count pair, print the word & count on one line.
    for (count_iter iter(counts.begin()); iter != counts.end(); ++iter)
        cout << iter->first << '\t' << iter->second << '\n';

    return 0;
}

注意上面的isalnum函数里面的第二个参数locale()：isalnum使用该参数指定的区域设置确定测试字符使用的字符集。字符集根据字符的数值确定它的标识。当程序运行时候，用户可以改变字符集，因此程序必须跟踪用户实际的字符集，而不能依赖编译程序运行时的有效字符集。

在C++中，区域设置（locale）是关于文化、地域、和语言信息的集合。区域设置包含的信息如下：

• l 格式化数字、货币、日期、时间
• l 分类字符
• l 字符大小写转换
• l 文本排序
• l 消息目录（用于翻译程序所使用的字符串）

每个C++程序都以最小的、标准区域设置开始，成为经典（classic）区域设置或者C语言设置。函数std::locale::classic()返回经典区域设置。未命名的区域设置（std::locale(“”)注意分号）是C++从操作系统获得的用户首选项。使用空字符串参数的区域设置成为本地区域设置。

经典区域设置的优点是他的行为已知并且是确定的，如果你的程序必须以固定格式读取数据，那么你就不想受用户首选项的影响。相反，本地区域设置格式的优点是由于某种原因设置首选项，并且想让程序以首选项的格式输出。习惯指定日期格式的某地的用户不想被指定为另外地区的格式。

因此，经典格式经常用于读写数据文件，本地格式用于翻译用户输入，并且将输出直接呈献给用户。

每个I/O流都有自己的locale对象，要改变流的locale，可以调用他的imbue函数，将locale对象作为唯一的参数传入。

换言之，在C++启动的时候，他会用经典区域设置初始化每个流，如：

std::cin.imbue(std::locale::classic());
std::cout.imbue(std::locale::classic());

加入要改变输出流使其采用用户的本地区域设置，可以在程序的开始使用下面的语句：

std::cout.imbue(std::locale(""));

当使用本地区域设置时，推荐定义一个类型为std::locale的变量，用于存储本地区域设置。可以将该变量传给isalnum、imbue或者其他的函数。通过创建此变量并分发他的副本，程序只需要向操作系统查询一次用户首选项，而非每次都需要查询。

改写的程序如下：

/** Creating and sharing a single locale object. */
#include <iostream>
#include <istream>
#include <locale>
#include <map>
#include <ostream>
#include <string>

int main()
{
    using namespace std;
    typedef map<string, int>    count_map;
    typedef count_map::iterator count_iter;

    locale native("");             // get the native locale
    cin.imbue(native);             // interpret the input and output according to
    cout.imbue(native);            // the native locale

    count_map counts;
    string word;

    // Read words from the standard input and count the number of times
    // each word occurs.
    while (cin >> word)
    {
        // Make a copy of word, keeping only alphabetic characters.
        string copy;
        for (string::iterator w(word.begin()); w != word.end(); ++w)
        if (isalnum(*w, native))
            copy.push_back(*w);
        // The "word" might be all punctuation, so the copy would be empty.
        // Don't count empty strings.
        if (not copy.empty())
        ++counts[copy];
    }

    // For each word/count pair, print the word & count on one line.
    for (count_iter iter(counts.begin()); iter != counts.end(); ++iter)
        cout << iter->first << '\t' << iter->second << '\n';

    return 0;
}

大小写转换

简单的大小写转换

任务：改写单词计数程序，将大写转换为小写并计算所有单词出现的次数。

示例代码如下：

/** Folding Uppercase to Lowercase Prior to Counting Words */
#include <iostream>
#include <istream>
#include <locale>
#include <map>
#include <ostream>
#include <string>

int main()
{
    using namespace std;
    typedef map<string, int>    count_map;
    typedef count_map::iterator count_iter;

    locale native("");             // get the native locale
    cin.imbue(native);             // interpret the input and output according to
    cout.imbue(native);            // the native locale

    count_map counts;
    string word;

    // Read words from the standard input and count the number of times
    // each word occurs.
    while (cin >> word)
    {
        // Make a copy of word, keeping only alphabetic characters.
        string copy;
        for (string::iterator w(word.begin()); w != word.end(); ++w)
        if (isalnum(*w, native))
            copy.push_back(tolower(*w, native));
        // The "word" might be all punctuation, so the copy would be empty.
        // Don't count empty strings.
        if (not copy.empty())
        ++counts[copy];
    }

    // For each word/count pair, print the word & count on one line.
    for (count_iter iter(counts.begin()); iter != counts.end(); ++iter)
        cout << iter->first << '\t' << iter->second << '\n';

    return 0;
}

稍微复杂的大小写转换

一提到复杂就会想到涉及到了地域字符集的转换，这一部分先不说吧，确实有点复杂。

3.0函数专题

1、关于函数

关于什么是函数，函数的定义和声明什么的和C语言的差不多，再次不再细细的说了。

2、再练单词计数

使用函数改写的程序如下：

/*************************************************************************
    > File Name: char_count_founction.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年05月25日 星期日 20时13分27秒
 ************************************************************************/

#include<iomanip>
#include<ios>
#include<iostream>
#include<locale>
#include<map>
#include<string>

using namespace std;

// Using Functions to Clarify the Word-Counting Program

typedef map<std::string, int>  count_map;  ///< Map words to counts
typedef count_map::iterator         count_iter; ///< Iterate over a @c count_map
typedef string::size_type      str_size;   ///< String size type

/** Initialize the I/O streams by imbuing them with
 * the given locale. Use this function to imbue the streams
 * with the native locale. C++ initially imbues streams with
 * the classic locale.
 * @param locale the native locale
 */
void initialize_streams(std::locale locale)
{
    cin.imbue(locale);
    cout.imbue(locale);
}

/** Find the longest key in a map.
 * @param map the map to search
 * @returns the size of the longest key in @p map
 */
str_size get_longest_key(count_map map)
{
    str_size result(0);
    for (count_iter iter(map.begin()); iter != map.end(); ++iter)
        if (iter->first.size() > result)
        result = iter->first.size();
    return result;
}

/** Print the word, count, newline. Keep the columns neatly aligned.
 * Rather than the tedious operation of measuring the magnitude of all
 * the counts and then determining the necessary number of columns, just
 * use a sufficiently large value for the counts column.
 * @param iter an iterator that points to the word/count pair
 * @param longest the size of the longest key; pad all keys to this size
 */
void print_pair(count_iter iter, str_size longest)
{
    const int count_size(10); // Number of places for printing the count
    cout << setw(longest)    << left  << iter->first <<
               setw(count_size) << right << iter->second << '\n';
}

/** Print the results in neat columns.
 * @param counts the map of all the counts
 */
void print_counts(count_map counts)
{
    str_size longest(get_longest_key(counts));

    // For each word/count pair...
    for (count_iter iter(counts.begin()); iter != counts.end(); ++iter)
        print_pair(iter, longest);
}

/** Sanitize a string by keeping only alphabetic characters.
 * @param str the original string
 * @param loc the locale used to test the characters
 * @return a santized copy of the string
 */
string sanitize(string str, locale loc)
{
    string result;
    for (string::iterator s(str.begin()); s != str.end(); ++s)
        if (isalnum(*s, loc))
        result.push_back(tolower(*s, loc));
    return result;
}

/** Main program to count unique words in the standard input. */
int main()
{
    locale native("");             // get the native locale
    initialize_streams(native);

    count_map counts;
    string word;

    // Read words from the standard input and count the number of times
    // each word occurs.
    while (std::cin >> word)
    {
        string copy(sanitize(word, native));

        // The "word" might be all punctuation, so the copy would be empty.
        // Don't count empty strings.
        if (not copy.empty())
        ++counts[copy];
    }

    print_counts(counts);

    return 0;
}

注释文档使用的格式是Doxygen.

3.函数参数

函数实参

有三种传递方式：按值传递，按引用传递、实参传递，

关于这三种传递的特性，不再赘述。

首先实参传递的示例：

/*************************************************************************
    > File Name: list2001_argument_parameter.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年05月27日 星期二 10时25分48秒
 ************************************************************************/
#include<algorithm>
#include<iostream>
#include<iterator>
#include<string>
#include<vector>

using namespace std;

// function
void modify(int x)
{
    x =10;
}

int triple(int x)
{
    return 3*x;
}

void print_vector(vector<int> v)
{
    cout << "{" ;
    copy (v.begin(), v.end(), ostream_iterator<int>(cout," "));
    cout << "}\n";
}

void add(vector<int> v, int a)
{
    for(vector<int>::iterator iter(v.begin()); iter!=v.end(); ++iter)
    {
        *iter = *iter *a ;
    }
}

int main()
{
    int a(42);
    modify(a);
    cout << "a" << a << endl;

    vector<int> data;
    data.push_back(10);
    data.push_back(20);
    data.push_back(30);
    data.push_back(40);

    print_vector(data);
    add(data, 30);
    print_vector(data);

    return 0;
}

结果如下：

按引用传递

/*************************************************************************
    > File Name: list2002_reference.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年05月27日 星期二 10时46分28秒
 ************************************************************************/

#include<algorithm>
#include<iostream>
#include<iterator>
#include<string>
#include<vector>

using namespace std;

// function
void modify(int& x)
{
    x =10;
}

/**当triple的参数为引用时候,不可以直接调用triple(14).
 *一言以蔽之,不能给数字赋值,只能给变量赋值.
 *在C++术语中,粗略的讲,变量出现在赋值的左侧时称为左值.仅能出现在赋值的右侧的称为右值.
 *整数字面量是一个很好的右值的例子.
 */
int triple(int x)
{
    return 3*x;
}

/**按引用传递值,并且阻止函数改变参数.
 *@const& v 声明参数v为不可变类型
 *参数从右往左读,首先是参数v,然后他是一个引用,引用的是一个const对象
 */
void print_vector(vector<int> const& v)
{
    cout << "{" ;
    // copy (v.begin(), v.end(), ostream_iterator<int>(cout," "));
    string separator("");
    // 取代上面的ostream_iterator, 使用const_iterator,可以防止向量的内容被改变,
    // 同时有可以实现迭代.
    for(vector<int>const_iterator i(v.begin()); i!=v.end(); i++ )
    {
        cout << *i << separator ;
        separator = ", ";
    }
    cout << "}\n";
}

void add(vector<int>& v, int a)
{
    for(vector<int>::iterator iter(v.begin()); iter!=v.end(); ++iter)
    {
        *iter = *iter *a ;
    }
}

int main()
{
    int a(42);
    modify(a);
    cout << "a" << a << endl;

    vector<int> data;
    data.push_back(10);
    data.push_back(20);
    data.push_back(30);
    data.push_back(40);

    print_vector(data);
    add(data, 30);
    print_vector(data);

    return 0;

}

结果如下：

3.1.函数重载

在讲解重载之前，需要讲一下有关简单的C++其他标准算法。

现在我们使用算法重写单词计数程序，使用transform将字符转换为小写，使用remove_if算法除去字符串中的非字母字符，remove_if算法对于序列中的每个元素调用一个函数，如果函数返回trueremove_if从序列中删除该元素（其实比没有删除）。不过C++中迭代器的的工作原理的有一个副作用，就是这个函数并没有真正的删除该元素，而是重新组织了这个序列，返回了超出需要保存的元素的末端的下一个位置。

原理如下图：

具体部分代码如下：

/** Sanitizing a String by Transforming It */

/** Test for non-letter.
 * @param ch the character to test
 * @return true if @p ch is not a character that makes up a word
 */
bool non_letter(char ch)
{
  return not isalnum(ch, std::locale());
}

/** Convert to lowercase.
 * Use a canonical form by converting to uppercase first,
 * and then to lowercase.
 * @param ch the character to test
 * @return the character converted to lowercase
 */
char lowercase(char ch)
{
  return std::tolower(ch, std::locale());
}

/** Sanitize a string by keeping only alphabetic characters.
 * @param str the original string
 * @return a santized copy of the string
 */
std::string sanitize(std::string str)
{
  // Remove all non-letters from the string, and then erase them.
  str.erase(std::remove_if(str.begin(), str.end(), non_letter),
            str.end());

  // Convert the remnants of the string to lowercase.
  std::transform(str.begin(), str.end(), str.begin(), lowercase);

  return str;
}

关于谓词：

首先上面的那个的bool non_letter(char ch)函数是一个谓词的例子，谓词是一个返回bool结果的函数。具体的请参阅相关资料，不再深入探讨。

其他的算法：

回文测试我们应该很熟悉，下面用C++实现。

代码如下：

/*************************************************************************
    > File Name: word_pal.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年05月30日 星期五 20时26分41秒
 ************************************************************************/
#include<algorithm>
#include<iostream>
#include<iterator>
#include<locale>
#include<string>

using namespace std;

/** 测试非字母
 * @param ch 带测试的字符
 * @return 如果@p ch 不是字母返回true
 */
 bool non_letter(char ch)
 {
    return not isalpha(ch, locale());
 }

 /** 转换为小写
  * 使用规范形式,先转换为大写,后转换为小写.
  * @param ch 待测试的字符
  * @return 转换后的字符
  */
char lowercase(char ch)
{
    return tolower(ch, locale());
}

/** 比较两个字符,不考虑大小写 */
bool same_char(char a, char b)
{
    return lowercase(a) == lowercase(b);
}

/** 确定@p str 是否包含回文
 * 只测试字母,不包括空格和标点
 * 空字符串不是回文
 * @param str 带测试的回文
 * @return 当@p str 顺读和倒读都一样的时候返回true
 */
bool is_palindrome(string str)
{
    string::iterator end(remove_if(str.begin(), str.end(), non_letter));
    string rev(str.begin(), end);
    reverse(rev.begin(), rev.end());
    return not rev.empty() and equal(str.begin(), end, rev.begin(), same_char);
}

int main()
{
    locale::global(locale(""));
    cin.imbue(locale());
    cout.imbue(locale());

    string line ;
    while(getline(cin, line))
    {
        if(is_palindrome(line))
        {
            cout << "这是一个回文: " << line << endl;
        }   

    }

    return 0;
}

重载

关于函数的重载和其他的高级语言一样样的。所以，我们会在以后的程序中再讲。。。。哈哈哈哈。

3.2回到数字

3.2.1长整型&短整型

使用number_limits获取整数的位数。

代码如下：

/*************************************************************************
    > File Name: list2301_int.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年06月03日 星期二 15时38分25秒
 ************************************************************************/

/** Discovering the Number of Bits in an Integer */
#include<iostream>
#include <limits>
#include<string>

using namespace std;

// numeric_limits获得整数的位数,并有一个返回值is_signed,即当数字有符号时返回true

int main()
{
    cout << "bits per int = ";
    if (numeric_limits<int>::is_signed)  // 如果有符号,加一,加上符号位
        cout << numeric_limits<int>::digits + 1 << '\n';
    else  // 否则直接输出
        cout << numeric_limits<int>::digits << '\n';

    cout << "bits per bool = ";
    if (numeric_limits<bool>::is_signed)
        cout << numeric_limits<bool>::digits + 1 << '\n';
    else
        cout << numeric_limits<bool>::digits << '\n';

    return 0;
}

下面的代码可以显示短整型和长整型的所占的位数：

/*************************************************************************
    > File Name: list2302_long.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年06月03日 星期二 15时44分42秒
 ************************************************************************/

/** Revealing the Number of Bits in Short and Long Integers  */
#include<iostream>
#include <limits>
#include<string>

using namespace std;

int main()
{
    cout << "bits per int = ";
    if (numeric_limits<int>::is_signed)
        cout << numeric_limits<int>::digits + 1 << '\n';
    else
        cout << numeric_limits<int>::digits << '\n';

    cout << "bits per bool = ";
    if (numeric_limits<bool>::is_signed)
        cout << numeric_limits<bool>::digits + 1 << '\n';
    else
        cout << numeric_limits<bool>::digits << '\n';

    cout << "bits per short int = ";
    if (numeric_limits<short>::is_signed)
        cout << numeric_limits<short>::digits + 1 << '\n';
    else
        cout << numeric_limits<short>::digits << '\n';

    cout << "bits per long int = ";
    if (numeric_limits<long>::is_signed)
        cout << numeric_limits<long>::digits + 1 << '\n';
    else
        cout << numeric_limits<long>::digits << '\n';

    cout << "bits per long long int = ";
    if (numeric_limits<long long>::is_signed)
        cout << numeric_limits<long long>::digits + 1 << '\n';
    else
        cout << numeric_limits<long long>::digits << '\n';

    return 0;
}

下面我们就可以演示一下重载了，顺便说明一下类型转换。

代码如下：

/*************************************************************************
    > File Name: list2303_print_overide.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年06月03日 星期二 16时08分45秒
 ************************************************************************/

/** Using Type Casts */
// 重载print函数,输出不同的数值类型
#include<iostream>
#include <locale>
#include<string>

using namespace std;

typedef signed char byte;

void print(byte b)
{
    // 操作符<<将signed char 当作变异的char,并尝试打印一个字符
    // 为了将该值打印为一个整数,必须将其转换为整数类型
    // static_cast() 表达式称为类型转换
    cout << "byte=" << static_cast<int>(b) << '\n';
}

void print(short s)
{
    cout << "short=" << s << '\n';
}

void print(int i)
{
    cout << "int=" << i << '\n';
}

void print(long l)
{
    cout << "long=" << l << '\n';
}

int main()
{
    cout.imbue(locale(""));
    print(0);
    print(0L);
    print(static_cast<short>(0));
    print(static_cast<byte>(0));
    print(static_cast<byte>(255));  // -1
    print(static_cast<short>(65535)); // -1
    print(32768);
    print(32768L);
    print(-32768);
    print(2147483647);
    print(-2147483647);
    // The following lines might work on your system.
    // If you are feeling adventuresome, uncomment the next 3 lines:
    print(2147483648); // long类型
    print(9223372036854775807);
    print(-9223372036854775807);

    return 0;
}

下面一个程序再次演示重载函数，同时演示类型转换和类型提升的区别。

代码如下：

/*************************************************************************
    > File Name: list2303_typePromotion.cpp
    > Author: suool
    > Mail: [email protected]
    > Created Time: 2014年06月03日 星期二 16时17分39秒
 ************************************************************************/

/** Overloading Prefers Type Promotion over Type Conversion */

/** 类型转换
 * 类型转换分为两步.
 * 当使用signed char和short类型时,编译器总是将他们转换为int,然后执行运算.这被称为类型提升.
 * 但是,对于一组重载函数且编译器需要知道调用哪个时,编译器首先做的事情是找一个精确的匹配,
 * 如果找不到,就会考虑类型提升之后的匹配,仅当这种匹配也失败的时候,才会搜索类型转换后能够匹配上的.
 * 因此,编译器优先考虑基于类型提升的匹配.
 */

// 具体如下面的程序.
#include<iostream>
#include<string>

using namespace std;

// print is overloaded for signed char, short, int and long
void print(signed char b)
{
    cout << "print(signed char = " << static_cast<int>(b) << ")\n";
}

void print(short s)
{
    cout << "print(short = " << s << ")\n";
}

void print(int i)
{
    cout << "print(int = " << i << ")\n";
}

void print(long l)
{
    cout << "print(long = " << l << ")\n";
}

// guess is overloaded for bool, int, and long
void guess(bool b)
{
    cout << "guess(bool = " << b << ")\n";
}

void guess(int i)
{
    cout << "guess(int = " << i << ")\n";
}

void guess(long l)
{
    cout << "guess(long = " << l << ")\n";
}

// error is overloaded for bool and long
void error(bool b)
{
    cout << "error(bool = " << b << ")\n";
}

void error(long l)
{
    cout << "error(long = " << l << ")\n";
}

int main()
{
    signed char byte(10);
    short shrt(20);
    int i(30);
    long lng(40);

    // 精确匹配各个类型
    cout << "第一次匹配的结果" << endl;
    print(byte);
    print(shrt);
    print(i);
    print(lng);

    // 前三个都自动提升为int类型
    // 因为guess函数没有相应的类型参数,所以无法精确匹配,需要提升类型
    cout << "第二次匹配的结果" << endl;
    guess(byte);
    guess(shrt);
    guess(i);
    guess(lng);

    // 由于error参数没有相应的类型,所以需要类型提升,先将signed char和short
    // 提升为int类型,但是guess没有int类型的参数,需要进行类型转换,此时guess函数中
    // 参数有long和bool两种,而类型转换,编译器认为所有转换的优先级相同,所以,此时编译器不知道
    // 该转换为long还是bool,即是不知道该调用那一个guess函数,因此会出现错误.
    // 要避免错误,只需要添加一个guess函数,参数为int即可.
    cout << "第三次匹配失败的结果" << endl;
//      error(byte); // expected error
//      error(shrt); // expected error
//      error(i);    // expected error
    error(lng);

    return 0;
}

结果如下：

3.2.1浮点数&定点数

首先用下面的代码演示浮点数的一些特性：

/*************************************************************************
> File Name: list2401_float.cpp
> Author: suool
> Mail: [email protected]
> Created Time: 2014年06月03日 星期二 17时14分59秒
************************************************************************/
/** Floating-Point Numbers Do Not Always Behave as You Expect */

#include<iostream>
#include<string>
#include <cassert>

using namespace std;

// 浮点数的比较!显示出浮点数在精度上的注意事项.
int main()
{
    float a(0.03f);
    float b(10.0f);
    float c(0.3f);
    cout << "a*b = " << a*b << endl;
    cout << "c = " << c << endl;
    assert(1 == 1);

    return 0;
}

结果如下：

下面演示三种浮点数格式的输出：

/*************************************************************************
> File Name: list2401_float_print.cpp
> Author: suool
> Mail: [email protected]
> Created Time: 2014年06月03日 星期二 17时29分32秒
************************************************************************/

/** Demonstrating Floating-Point Output */
// 浮点数输出示例,三种格式的浮点数输出.
#include <ios>
#include<iostream>
#include<string>

using namespace std;

/// Print a floating-point number in three different formats.
/// @param precision the precision to use when printing @p value
/// @param value the floating-point number to print
void print(int precision, float value)
{
    cout.precision(precision);
    cout << "科学计数法格式输出" << endl;
    cout << scientific << value << '\n';
    cout << "定点数格式输出" << endl;
    cout << fixed      << value << '\n';
    // Set the format to general.
    cout.unsetf(ios_base::floatfield);
    cout << "一般格式输出"<< endl;
    cout << value << '\n';
}

/// Main program.
int main()
{
    print(6, 123456.789f);
    print(4, 1.23456789f);
    print(2, 123456789.f);
    print(5, -1234.5678e9f);

    return 0;
}

/*
  三种格式的浮点数输出说明
  首先是precision(int)的说明:
  关于setprecision(int)，MSDN上的解释为：
  即当输出的数据类型为浮点型时，setprecision(int)表示设置输出数的有效位数，
  当输出的是定点数或用科学计数法表示的数时，setprecison(int)表示设置输出数小数点后的位数。
  故通常控制浮点数输出时小数点后的位数的做法为：先将要输出的数设置为定点数,然后使用setprecision(int).

  然后关于科学格式:
  指数被打印为e或者E,随后是基数为10的指数.且指数有符号,即使指数为0,也至少有两位数字
  关于定点格式:
  不打印指数,小数点前有多少位打印多少位,小数点总是被打印,精度取决与小数点后的数字的位数.
  关于默认格式:
  如果指数小于或者等于-4,或者说大于精度,数字会以科学格式打印.
  否则,以无指数格式打印,但是不像传统的定点输出,小数点后的0会被移除.
  需要时,值会以四舍五入的来适应分配的精度.
 */

结果如下：

Over， 第一部分C++基础！

第三部分预计会推迟几天，，要复习，快考试了。。

C++基础学习教程（四）