《C++面向对象程序设计》课后答案

  • 更新时间:
  • 2987人关注
  • 点击下载

给大家带来的是关于C++相关的课后习题答案下载,介绍了关于C++、面向对象、程序设计方面的内容,由聂乐池 网友提供,本资源目前已被939人关注,高等院校C++类教材综合评分为:8.6分

资源详情相关推荐
《C++面向对象程序设计》封面
  • 出版社:电子工业出版社
  • 作者:杜茂康、吴建、王永
  • 大小:5.82 MB
  • 类别:C++
  • 热度:152
  • C++程序设计与实例
  • C++程序设计
  • C++面向对象程序设计教程(第3版)
  • C++程序设计(第二版)
  • C++语言程序设计(第4版)
  • C++面向对象程序设计这本书主要介绍了标准C++面向对象的程序设计技术,以及用VisualC++进行面向对象的Windows程序设计的基本原理和方法,可作为高等院校计算机、电子信息类专业及其他理工类相关专业的教材,也可作为C++语言自学者或程序设计人员的参考用书。

    本书深入浅出地介绍了标准C++面向对象的程序设计技术,以及用VisualC++进行面向对象的Windows程序设计的基本原理和方法,包括C++对C语言的扩展、类、对象、友元、继承、多态性、虚函数、重载、I/O流类库、文件、模板与STL、C++Windows程序的结构、消息驱动、MFC应用程序框架、GDI、菜单、对话框、工具栏、文档与视图等内容。

    全书本着易于理解、实用性强的原则设计其内容和案例,并以一个规模较大的综合性程序的编制贯穿于C++面向对象技术和Windows程序设计的全过程,引导读者理解和领会面向对象程序设计的思想、技术、方法和要领,掌握在Windows程序中应用自定义类实现程序功能的软件开发方法。

    本书取材新颖,内容全面,通俗易懂,可作为高等院校计算机、电子信息类专业及其他理工类相关专业的教材,也可作为C++语言自学者或程序设计人员的参考用书。

    目录

    • 第1章 C++与面向对象程序设计概述1
    • 1.1 面向过程与面向对象程序设计1
    • 1.2 面向对象程序语言的特征3
    • 1.3 C++与面向对象程序设计6
    • 1.4 C++程序的结构7
    • 1.5 数据输入与输出10
    • 1.5.1 流的概念10
    • 1.5.2 cin和析取运算符>>10
    • 1.5.3 cout和插入运算符<<12
    • 1.5.4 输出格式控制符14
    • 1.5.5 数制基数15
    • 1.6 编程实作——VC++ 6.0编程简介16
    • 1.6.1 在VC++中编辑源程序16
    • 1.6.2 编译和调试程序18
    • 1.6.3 关于Visual C++的项目工作区文件19
    • 1.6.4 利用Visual C++向导创建应用程序20
    • 习题121
    • 第2章 C++基础22
    • 2.1 C++对C语言数据类型的扩展22
    • 2.2 局部变量声明23
    • 2.3 指针23
    • 2.3.1 指针概念的回顾23
    • 2.3.2 指针与0和void*24
    • 2.3.3 new和delete25
    • 2.4 引用27
    • 2.5 const常量29
    • 2.5.1 常量的定义29
    • 2.5.2 const与指针30
    • 2.5.3 const与引用31
    • 2.6 类型转换32
    • 2.6.1 隐式类型转换32
    • 2.6.2 显式类型转换33
    • 2.7 函数34
    • 2.7.1 函数原型34
    • 2.7.2 函数默认参数36
    • 2.7.3 函数与引用36
    • 2.7.4 函数与const40
    • 2.7.5 函数重载41
    • 2.8 内联函数43
    • 2.9 typedef44
    • 2.10 命名空间44
    • 2.11 预处理器47
    • 2.12 作用域和生命期48
    • 2.12.1 作用域48
    • 2.12.2 变量类型及生命期50
    • 2.12.3 变量初始化52
    • 2.12.4 局部变量与函数返回地址52
    • 2.13 文件输入和输出53
    • 2.14 编程实作54
    • 习题256
    • 第3章 类与对象59
    • 3.1 结构与类59
    • 3.1.1 C++对结构的扩展59
    • 3.1.2 类60
    • 3.2 成员函数62
    • 3.2.1 成员函数的定义62
    • 3.2.2 常量成员函数63
    • 3.3 类与封装64
    • 3.4 对象65
    • 3.5 构造函数67
    • 3.5.1 构造函数67
    • 3.5.2 无参构造函数69
    • 3.5.3 重载构造函数71
    • 3.5.4 拷贝构造函数72
    • 3.5.5 构造函数与初始化列表75
    • 3.6 析构函数77
    • 3.7 静态成员79
    • 3.8 this指针82
    • 3.9 类对象成员85
    • 3.10 对象数组和对象指针88
    • 3.11 向函数传递对象89
    • 3.12 类的作用域和对象的生存期90
    • 3.13 友元92
    • 3.14 编程实作:类的接口与实现的分离94
    • 3.14.1 头文件94
    • 3.14.2 源文件95
    • 3.14.3 对类的应用96
    • 习题398
    • 第4章 继承102
    • 4.1 继承的概念102
    • 4.2 protected和继承103
    • 4.3 继承方式104
    • 4.4 基类与派生类的关系107
    • 4.4.1 成员函数的重定义和名字隐藏107
    • 4.4.2 基类成员访问109
    • 4.5 构造函数和析构函数109
    • 4.5.1 派生类构造函数、析构函数的定义和调用次序109
    • 4.5.2 构造函数和析构函数的构造规则110
    • 4.5 多继承115
    • 4.5.1 多继承的概念和应用115
    • 4.5.2 多继承方式下成员名的二义性117
    • 4.5.3 多继承的构造函数与析构函数117
    • 4.6 虚拟继承119
    • 4.7 基类与派生类对象的关系123
    • 4.8 继承与组合125
    • 4.9 编程实作125
    • 习题4130
    • 第5章 多态性133
    • 5.1 静态绑定和动态绑定133
    • 5.2 虚函数133
    • 5.2.1 虚函数的意义133
    • 5.2.2 虚函数的特性136
    • 5.3 虚析构函数140
    • 5.4 纯虚函数与抽象类141
    • 5.4.1 纯虚函数和抽象类141
    • 5.4.3 抽象类的应用143
    • 5.4 运行时类型信息149
    • 5.4.1 dynamic_cast149
    • 5.4.2 typeid153
    • 5.5 编程实作154
    • 习题5156
    • 第6章 运算符重载159
    • 6.1 运算符重载基础159
    • 6.2 重载二元运算符161
    • 6.2.1 类与二元运算符重载161
    • 6.2.2 友元二元运算符重载的特殊用途164
    • 6.3 重载一元运算符166
    • 6.3.1 作为成员函数重载166
    • 6.3.2 作为友元函数重载167
    • 6.4 特殊运算符重载169
    • 6.4.1 运算符++和--的重载169
    • 6.4.2 重载赋值运算符=171
    • 6.4.3 重载[]173
    • 6.4.4 类与其他数据类型之间的转换175
    • 6.5 输入/输出运算符重载177
    • 6.5.1 重载输出运算符<<177
    • 6.5.2 重载输入运算符>>177
    • 6.5.3 重载运算符<<和>>举例178
    • 6.6 编程实作179
    • 习题6183
    • 第7章 模板与STL186
    • 7.1 模板概念186
    • 7.2 函数模板与模板函数187
    • 7.2.1 函数模板的定义187
    • 7.2.2 函数模板的实例化188
    • 7.2.3 模板参数189
    • 7.3 类模板192
    • 7.3.1 类模板的概念192
    • 7.3.2 类模板的定义192
    • 7.3.3 类模板实例化194
    • 7.3.4 类模板的使用196
    • 7.4 STL197
    • 7.4.1 容器197
    • 7.4.2 迭代器205
    • 7.4.3 关联式容器207
    • 7.4.4 算法211
    • 7.5 编程实作214
    • 习题7216
    • 第8章 异常217
    • 8.1 异常处理概述217
    • 8.2 C++异常处理基础218
    • 8.2.1 异常处理的结构218
    • 8.2.2 异常捕获219
    • 8.3 异常与函数220
    • 8.4 异常处理的几种特殊情况222
    • 8.5 异常和类225
    • 8.5.1 构造函数与异常225
    • 8.5.2 异常类226
    • 8.5.3 派生异常类的处理230
    • 习题8232
    • 第9章 文件与流235
    • 9.1 C++ I/O流及流类库235
    • 9.2 使用I/O成员函数236
    • 9.2.1 istream流中的常用成员函数237
    • 9.2.2 ostream流中的常用成员函数239
    • 9.2.3 数据输入、输出的格式控制240
    • 9.3 文件操作242
    • 9.3.1 文件与流243
    • 9.3.2 二进制文件245
    • 9.3.3 随机文件249
    • 习题9250
    • 第10章 C++ Windows程序设计基础253
    • 10.1 Windows程序设计基础253
    • 10.1.1 窗口253
    • 10.1.2 事件驱动和消息响应253
    • 10.1.3 Windows程序的文件构成254
    • 10.1.4 Visual C++的Windows程序设计方法255
    • 10.2 Windows程序设计的常用数据结构256
    • 10.3 Windows程序的基本结构259
    • 10.4 Windows程序的控制流程261
    • 10.5 Windows程序的数据输出267
    • 10.6 消息驱动程序设计270
    • 习题10273
    • 第11章 MFC程序设计275
    • 11.1 MFC程序基础275
    • 11.1.1 MFC类275
    • 11.1.2 MFC程序的结构277
    • 11.1.3 MFC程序的执行流程279
    • 11.1.4 消息映射281
    • 11.2 应用程序框架283
    • 11.2.1 应用程序框架的概念283
    • 11.2.2 用向导建立应用程序框架283
    • 11.2.3 应用程序框架的结构286
    • 11.2.4 应用程序框架类之间的关系292
    • 11.3 MFC程序的数据输出294
    • 11.3.1 MFC中的图形类294
    • 11.3.2 绘图对象296
    • 11.3.3 用MFC向导添加消息映射函数297
    • 11.3.4 OnPaint函数与输出302
    • 11.4 对话框304
    • 11.4.1 对话框的类型304
    • 11.4.2 用资源编辑器建立对话框304
    • 11.5 菜单和工具栏310
    • 11.5.1 直接修改应用程序框架的菜单310
    • 11.5.2 建立新菜单栏313
    • 11.5.3 工具栏操作314
    • 11.6 视图与文档315
    • 习题11318
    • 第12章 综合程序设计320
    • 12.1 在应用程序框架中包含并修改自定义类320
    • 12.2 在事件函数中操作类对象322
    • 12.3 添加对话框325
    • 12.4 添加程序菜单327
    • 12.5 文档序列化331
    • 习题12341
    • 参考文献342
    展开阅读
    精选笔记1:C++实现各种排序算法类汇总

    24小时19分钟前回答

    C++可实现各种排序算法类,比如直接插入排序、折半插入排序、Shell排序、归并排序、简单选择排序、基数排序、对data数组中的元素进行希尔排序、冒泡排序、递归实现、堆排序、用数组实现的基数排序等。

    具体代码如下:

    #ifndef SORT_H
    #define SORT_H
    #include <iostream>
    #include <queue>
    using namespace std;
    // 1.直接插入排序
    template<class ElemType>
    void InsertSort(ElemType data[], int n);
    // 2.折半插入排序
    template<class ElemType>
    void BInsertSort(ElemType data[], int n);
    // 3.Shell排序
    // 对data数组中的元素进行希尔排序,n为该数组大小
    // increments为增量序列,incrementsLength为增量序列的大小
    template<class ElemType>
    void ShellSort(ElemType data[],int increments[], int n, int incrementsLength);
    // 1.Bubble Sort
    template<class ElemType>
    void BubbleSort(ElemType data[], int n);
    // 2.快速排序
    template<class ElemType>
    void QuickSort(ElemType data[], int n);
    ////////////////// 
    // Merge Sort
    ////////////////// 
    // 归并排序
    template<class ElemType>
    void MergeSort(ElemType data[],int n);
    template<class ElemType>
    void MergeSortNonRecursion(ElemType data[], int n);
    ////////////////// 
    // Selection sort
    ////////////////// 
    // 简单选择排序
    template<class ElemType>
    void SelectionSort(ElemType data[], int n);
    // 堆排序
    template<class ElemType>
    void HeapSort(ElemType data[],int n);
    ///////////////
    // Radix Sort
    ///////////////
    // 静态链表结点
    const int DIGITS = 10;
    const int RADIX = 10;
    class SLList;
    ostream& operator<<(ostream& os, SLList &s);// 由于VC++6.0使用using namespace std对于友元不支持
          // 故在类SLList之前做前向声明
          // 若使用其他C++编译器,这两句可删去
    // 静态链表static linked list
    // [0]:头结点
    class SLList
    {
     struct Node
     {
     int  key[DIGITS];
     int    info;
     int    next;
     }; 
      
     friend ostream& operator<<(ostream& os, SLList &s);
    public:
     SLList():data(NULL),length(0){};
      ~SLList();
     void Arrange();       
      void Init(int arr[],int n);
      void RadixSort();
    private:
      void Distribute( int[], int[], int);
     void Collection( int[], int[], int);
      Node *data;
      int length;
    };
    // 基数排序
    void RadixSort(int data[], int n);
    //void RadixSort(SLList&);
    ///////////////
    // util
    ///////////////
    template<class ElemType>
    void Swap( ElemType& a, ElemType& b)
    {
      ElemType c = a;
      a = b;
      b = c;
    }
    int init(int** data);
    template<class ElemType>
    void print(ElemType data[],int begin,int end);
    // 直接插入排序,数组data用于存放待排序元素,n为待排序元素个数
    template<class ElemType>
    void InsertSort(ElemType data[], int n)
    { 
      ElemType tmp;
     int i, j;
      for (i = 1; i < n; i++){
        if ( data[i] > data[i - 1])
          continue;
        tmp = data[i];                // 保存待插入的元素
     data[i] = data[i - 1];
        for ( j = i - 1; j > 0 && data[j - 1] > tmp;j--)
          data[j] = data[j - 1];          // 元素后移
        data[j] = tmp;                // 插入到正确位置    
      }
    }
    // 折半插入排序
    template<class ElemType>
    void BInsertSort(ElemType data[], int n)
    { 
      ElemType tmp;
     int i, j, mid, low, high;
      for (i = 1; i < n; i++){
        tmp = data[i];           // 保存待插入的元素
        low = 0;
        high = i-1;
        while (low <= high){        // 在data[low..high]中折半查找有序插入的位置
          mid = (low + high) / 2;      // 折半
          if( tmp < data[mid])
            high = --mid;         // 插入点在低半区
          else
            low = ++mid;         // 插入点在高半区
        }
        for(j = i - 1; j >= low; j--)
          data[j + 1] = data[j];     // 元素后移
        data[low] = tmp;          // 插入到正确位置
      }
    }
    // 对data数组中的元素进行希尔排序,n为该数组大小
    // increments为增量序列,incrementsLength为增量序列的大小
    template<class ElemType>
    void ShellSort(ElemType data[], int increments[], int n, int incrementsLength)
    {
      int i, j, k;
      ElemType tmp;
     for ( k = 0; k < incrementsLength; k++){    // 进行以increments[k]为增量的排序
        for ( i = increments[k]; i < n; i++){
          tmp = data[i];
          for ( j = i; j >= increments[k]; j -= increments[k]){
            if ( tmp >= data[j - increments[k]])
              break; 
            data[j] = data[j - increments[k]]; 
          }
          data[j] = tmp;
        }
      }
    }
    // 冒泡排序
    template<class ElemType>
    void BubbleSort(ElemType data[], int n)
    {
     int lastSwapIndex = n - 1; // 用于记录最后一次交换的元素下标
     int i, j;
      for (i = lastSwapIndex; i > 0;i = lastSwapIndex)
     {
     lastSwapIndex = 0;
     for (j = 0; j < i; j++)
      if (data[j] > data[j + 1]){
            Swap( data[j],data[j + 1]);
      lastSwapIndex = j;
      }
     }
    }
    //快速排序
    template<class ElemType>
    int Partition(ElemType data[] , int low , int high)  
    {  
      ElemType pivot = data[low];  
      while (low < high){  
        while (low < high && data[high] >= pivot) 
      high--;  
        data[low] = data[high]; 
        while (low < high && pivot >= data[low]) 
      low++;  
        data[high] = data[low];  
      }  
      data[low] = pivot;  
      return low;  
    }  
    template<class ElemType>
    void QuickSort(ElemType data[], int begin, int end)
    { 
      if (begin >= end) 
     return;
      int pivot = Partition(data , begin , end);  
      QuickSort(data , begin , pivot - 1);  
      QuickSort(data , pivot + 1, end);     
    }
    template<class ElemType>
    void QuickSort(ElemType data[], int n)
    {
      if (n < 2)
        return;
      QuickSort(data, 0, n-1);
    }
    // 将数组data中,[lptr...rptr-1][rptr...rightEnd]两部分的元素进行合并
    // tmpArr为合并时的辅存空间
    template<class ElemType>
    void Merge(ElemType data[], ElemType tmpArr[], int lptr, int rptr, int rightEnd)
    {
      int leftEnd = rptr - 1;
      int ptr,i;
      ptr = i = lptr;
      while (lptr <= leftEnd && rptr <= rightEnd)
        if (data[lptr] <= data[rptr])
          tmpArr[ptr++] = data[lptr++];
        else
          tmpArr[ptr++] = data[rptr++];
      while (lptr <= leftEnd)
        tmpArr[ptr++] = data[lptr++];
      while (rptr <= rightEnd)
        tmpArr[ptr++] = data[rptr++];
      for (;i <= rightEnd; i++)
        data[i] = tmpArr[i];
    }
    // 递归实现
    // 将数组data中,[begin...end]的元素进行归并排序
    template<class ElemType>
    void MSort(ElemType data[], ElemType tmpArr[], int begin, int end)
    {
      int middle;
      if ( begin >= end)
        return;
      middle = (begin + end)/2;   // 将data平分为[begin..middle]和[middle..end]
      MSort( data, tmpArr, begin, middle);  // 递归前半部分
      MSort( data, tmpArr, middle + 1, end);  // 递归后半部分
      Merge( data, tmpArr, begin, middle + 1, end); // 将data[begin..middle],data[middle..end]进行归并
    }
    template<class ElemType>
    void MergeSort(ElemType data[], int n)
    {
      ElemType* pArr = NULL;
      pArr = new ElemType[n];
      MSort( data,pArr,0,n-1);
      delete[] pArr;
    }
    // 非递归实现
    template<class ElemType>
    void MPass(ElemType data[], ElemType tmpArr[], int n, int mergeLength)
    {
     int i = 0;
     while (i <= n - 2 * mergeLength){
     Merge(data, tmpArr, i, i + mergeLength, i + 2 * mergeLength - 1);
     i = i + 2 * mergeLength;
     }
     if (i + mergeLength < n)
     Merge(data, tmpArr, i, i + mergeLength, n - 1);
    }
    template<class ElemType>
    void MergeSortNonRecursion(ElemType data[], int n)
    {
     int mergeLength = 1;
     ElemType* pArr = NULL;
     pArr = new ElemType[n];
     while (mergeLength < n){
     MPass(data, pArr, n, mergeLength);
     mergeLength *= 2;
     }
     delete[] pArr;
    }
    // 简单选择排序
    template<class ElemType>
    void SelectionSort(ElemType data[], int n)
    {
     int i, j, min;
      for (i = 0; i < n; i++){
        min = i;
        for (j = i + 1; j < n; j++){
          if ( data[j] < data[min])
            min = j;
        }
        Swap(data[i],data[min]);
      }
    }
    // 堆排序
    // i为指定元素在数组中的下标
    // 返回指定结点的左孩子在数组中的下标
    inline int LeftChild(int i)
    {
      return 2 * i + 1;
    }
    template<class ElemType>
    void HeapAdjust(ElemType data[], int i, int n)
    {
      ElemType tmp;
      int child;
      for ( tmp = data[i]; LeftChild(i) < n; i = child){
        child = LeftChild(i);
        if (child != n - 1 && data[child + 1] > data[child])  // 取较大的孩子结点
          child++;
        if (tmp < data[child])                
          data[i] = data[child];
        else
          break;
      }
      data[i] = tmp;
    }
    template<class ElemType>
    void HeapSort(ElemType data[], int n)
    {
      int i;
      for (i = n/2; i >= 0; i--)  // 建堆
        HeapAdjust(data, i, n);
      for (i = n - 1;i > 0; i--){  // 将堆的根结点与最后的一个叶结点交换,并进行调整
        Swap(data[0],data[i]);
        HeapAdjust(data, 0, i);
      }
    }
    // 用数组实现的基数排序
    void RadixSort(int data[], int n)
    {
      const int radix = 10;
      const int digits = 10;
      int i,j,k,factor;
     queue<int> queues[radix];
      for ( i = 0,factor = 1; i < digits;i++,factor *= radix){
        for ( j = 0;j < n; j++)
          queues[(data[j]/factor)%radix].push(data[j]);    // 分配
        for ( k = j = 0; j < radix; j++,k++)          // 收集
          while (!queues[j].empty()){
            data[k] = queues[j].front();
            queues[j].pop();
          }
      }
    }
    // 分配
    void SLList::Distribute(int front[], int rear[], int digit)
    {
     int i, index;
     for (i = 0; i < RADIX; i++)
     front[i] = 0;
     for (i = data[0].next; i > 0; i = data[i].next){
     index = data[i].key[digit];
     if (front[index] == 0)
      front[index] = i;
     else
      data[rear[index]].next = i;
     rear[index] = i;
     }
    }
    // 收集
    void SLList::Collection(int front[], int rear[], int digit)
    {
     int i, current;
     for (i = 0; front[i] == 0; i++); // 找到第一个非空子表
     data[0].next = front[i];  // 头结点指向第一个非空子表中第一个结点
     current = rear[i++];
     for (; i < RADIX; i++){
     if (front[i] == 0)
      continue;
     data[current].next = front[i]; // 链接两个非空子表
     current = rear[i];
     }
     data[current].next = 0;
    }
    // 用SLList实现的基数排序
    void SLList::RadixSort()
    {
      int i;
      int front[RADIX],rear[RADIX];
      // 从最低位优先依次对各关键字进行分配收集
      for ( i = 0; i < DIGITS; i++){
        Distribute(front, rear, i);
        Collection(front, rear, i);    
      }
    }
    SLList::~SLList()
    {
      delete[] data;
      length = 0;
    }
    void SLList::Init(int arr[], int n)
    {
      length = n + 1;
      if (data != NULL)
        delete[] data;
      data = new Node[n + 1];
      data[0].next = 1;
      for ( int i = 1; i <= n; i++){
        int value = data[i].info = arr[i - 1];
        for (int j = 0;j < 10; j++){
          data[i].key[j] = value % 10;// + '0';
          value /= 10;
        }
        data[i].next = i + 1;
      }
      data[n].next = 0;
    }
    // 根据链表中各结点的指针值调整元素位置,使得SLList中元素按关键字正序排列
    void SLList::Arrange()
    {
     int i, tmp;
     int current = data[0].next;   // current存放第一个元素的当前位置
     for (i = 1; i < length; i++){
     while (current < i)   // 找到第i个元素,并用current存放其在静态链表中当前位置
      current = data[current].next;
     tmp = data[current].next;
     if (current != i){
      Swap(data[current], data[i]); // 第i个元素调整到位
      data[i].next = current;  // 指向被移走的元素
     }
     current = tmp;    // 为找第i + 1个元素做准备
     }
    }
    ostream& operator<<(ostream& os,SLList &s)
    {
     for (int i = 1; i < s.length; i++)
     cout << s.data[i].info << " ";
     os << endl;
     return os;
    }
    #endif
    展开阅读
    精选笔记2:2~62位任意进制转换方法(c++)

    7小时23分钟前回答

    进制转换的符号表为[0-9a-zA-Z],共61个字符,最大可表示62进制。

    思路是原进制先转换为10进制,再转换到目标进制。

    疑问:

    对于负数,有小伙伴说可以直接将符号丢弃,按照整数进行进位转换,最后再将负号补回来,我认为这种做法是不对的。

    正确的做法是:考虑好按照16位(short)还是32位(int)抑或64位(long long),先求出二进制补码(这时候就正负数就统一了),将二进制数转换为十进制后在转换为其他进制(如果有小伙伴知道如何直接将二进制转换为任意进制的方法可以留言告诉我,不胜感激。注意这里的任意进制不是单纯的8 16等2的幂次进制,还有其他的比如7、9等)。

    下面贴上这种我认为针对负数的处理方法不太合适的代码:

    输入格式:原进制,目标进制,原进制下的数字(用字符串表示)

    输出格式:目标进制下的数字

    #include <iostream>
    #include <string>
    #include <cmath>
    using namespace std;
    
    //将任意字符转换为十进制,其中a-z代表10-35,A-Z代表36-61,用对应的ASCII码调整就好
    long long convertToDec(char c)
    {
     long long decNum;
     if(c>='a' && c<='z')
      decNum=c-87;
     else if(c>='A' && c<='Z')
      decNum=c-29;
     else if(c>='0' && c<='9')
      decNum=c-48;
    
     return decNum;
    }
    
    //将十进制转换为这些字符
    char convertToDec(long long c)
    {
     long long objchar;
     if(c>=10 && c<=35)
      objchar=c+87;
     else if(c>=36 && c<=61)
      objchar=c+29;
     else if(c>=0 && c<=9)
      objchar=c+48;
    
     return objchar;
    }
    
    int main()
    {
     int src;
     int obj;
     string num;
    
     while(cin>>src>>obj>>num)
      {
    
       bool IsNegative=false;
       if(num[0]=='-')
        {
         num.erase(0);
         IsNegative=true;
        }
    
       long long decNum=0;//十进制数(中间数)
       for(long long i=0;i<num.size();++i)
        decNum+=convertToDec(num[i])*pow(src,num.size()-1-i);
    
       string strTmp;
       long long tmp;
       while(decNum>0)
        {
         tmp=decNum % obj;
         strTmp=convertToDec(tmp)+strTmp;
         decNum/=obj;
        }
    
       if(IsNegative)
        strTmp='-'+strTmp;
       cout<<strTmp<<endl;
      }
    
     return 0;
    }

    以上这篇2~62位任意进制转换方法(c++)就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持码农之家。

    展开阅读

    C++相关资源

    • C++语言程序设计(第3版)

      C++语言程序设计(第3版)

      本书将C++语言作为大学生学习程序设计的人门语言,不仅详细介绍了语言本身,而且介绍了常用的数据结构和算法。全书以面向对象的程序设计方法贯穿始终,每一章都首先阐述面向对象的程序设计思想和方法,然后引出必要的语法知识,在讲解语法时着重从程序设计方法学的角度讲述其意义和 用途,力求使读者在掌握C++语言的同时,能够对现实世界中较简单的问题及其解决方法用计算机语言进行描述。针对初学者和自学读者的特点,书中以结合实例讲解基本概

      大小:4.74 MBC++语言

      立即下载
    • c++程序设计语言

      c++程序设计语言

      本书是与Bjarne Stroustrup的《C++程序设计语言》一书配套使用的习题解答,为从《C++程序设计语言》中精选出来的许多练习提供了富有见解的、容易领会的解答,并且附有大量对该书的交叉引用,以便于读者更好地将两本书结合使用。此外,作者对有关练习给出了细致的解释,并为每个选出的练习提供极有价值的提示,以便读者能够找出自己的解答。本书的补充练习提供了对现代软件设计的深入见解,并通过解决一组富有启发性和现实性的练习帮助读者深

      大小:521 KBc++语言

      立即下载
    • C/C++语言硬件程序设计:基于TMS320C5000系列DSP

      C/C++语言硬件程序设计:基于TMS320C5000系列DSP

      C/C++语言硬件程序设计——基于TMS320C5000系列DSP 作者:陈天麒 西安电子科技大学 出版日期:2003年5月 本书全面介绍了使用C/C++高级语言开发TMS320C5000系列DSP应用系统的方法。全书共分为七章,内容包括TMS320C5000系列开发平台、TMS320C5000系列硬件基础、C/C++程序设计、DSP/BIOS程序设计、RTDX程序设计、BootLoader程序设计和应用实例。本书的特色在于通过完整的程序实例介绍相关的内容。 本书是作者近几年来不间断地从事TMS320系列

      大小:7.2MB程序设计

      立即下载
    • C++面向对象程序设计

      C++面向对象程序设计

      前一时期,人们编写的程序多是面向过程的,设计者必须充分地考虑到程序的每一个细节,要指定程序在每一瞬时应执行的动作。C语言是面向过程的结构化和模块化的语言,用于处理小型问题时得心应手,但在处理大型问题时就显得力不从心了。为了处理大型程序的需要,计算机科学家提出了面向对象程序设计的理论,并于20世纪末期在C语言的基础上研制出支持面向对象的C++语言,为处理大程序提供了有力的工具。 近年来,国内许多大学的计算机类专业

      大小:10.2 MBC++

      立即下载
    • C++面向对象程序设计(第2版)

      C++面向对象程序设计(第2版)

      前一时期,人们编写的程序多是面向过程的,设计者必须充分地考虑到程序的每一个细节,要指定程序在每一瞬时应执行的动作。C语言是面向过程的结构化和模块化的语言,用于处理小型问题时得心应手,但在处理大型问题时就显得力不从心了。为了处理大型程序的需要,计算机科学家提出了面向对象程序设计的理论,并于20世纪末期在C语言的基础上研制出支持面向对象的C++语言,为处理大程序提供了有力的工具。 近年来,国内许多大学的计算机类专业

      大小:10.8 MBC++

      立即下载
    • C++程序设计语言(第1-3部分)

      C++程序设计语言(第1-3部分)

      《C 程序设计语言》(原书第4版) 是C 领域最经典的参考书,介绍了C 11的各项新特性和新功能。全书共分四部分。第一部分(第1~5章)是引言,包括C 的背景知识,C 语言及其标准库的简要介绍

      大小:157.9 MBC++

      立即下载

    学习笔记

    4小时47分钟前回答

    C++ Custom Control控件向父窗体发送对应的消息

    向父窗体发送消息 ,这里只讲发送 WM_NOTIFY 消息, 其它消息是相同的 在 控件中的某个函数中 设置发送消息的程序 首先定义一个WM_NOTIFY消息的专用结构. NMHDR nm;nm.code = 123456; // 这里是消息的区别代码nm.hwndFrom = m_hWnd;//这是控件的HWND句柄nm.idFrom = GetDlgCtrlID();//这是得到的对话框的IDCWnd* pWnd; pWnd = GetParent(); //得到父窗体 窗口 if (pWnd != NULL) { pWnd-SendMessage(WM_NOTIFY, nm.idFrom, (LPARAM) //向父窗体发送消息 } 这样就可以将消息发送到父窗体了. 在父窗体的代码中,只需要处理WM_NOTIFY消息就可以了,也就是实现on_notify的虚函数 BOOL CMyControlDlg::OnNotify(WPARAM wParam, LPARAM lParam, LRESULT* pResult){ if ((UINT)wParam == IDC_CUSTOM2) { AfxMessageBox(_T(……

    19小时4分钟前回答

    C++开发之CRC校验实例详解

    CRC:(循环冗余校验) 循环冗余校验是数据通信领域中最常用的一种差错校验码,主要用来检测或校验数据传输或者保存后可能出现的错误。其特征是信息字段和校验字段的长度可以任意选定。 工作原理: CRC检错方法的工作原理可以从发送端与接收端两个方面进行描述。 1)发送端将发送数据比特序列当作一个多项式f(x),用双方预先约定的生成多项式G(x)去除,求得一个余数多项式R(x)。将余数多项式加到数据多项式之后,一起发送到接收端。 2)接收端用同样的生成多项式G(x)去除接收到的数据多项式f'(x),得到计算余数R'(x)。如果计算余数多项式R'(x)与接收余数多项式R(x)相同,表示传输无差错……

    8小时28分钟前回答

    C++类的成员初始化列表的相关问题总结

    在以下四中情况下,要想让程序顺利编译,必须使用成员初始化列表(member initialization list): 1, 初始化一个引用成员(reference member); 2, 初始化一个常量对象(const member); 3, 调用一个基类的构造函数,且该基类的构造函数有一组参数; 4, 调用一个成员类(member class)的构造函数,且该构造函数有一组参数 这四种情况程序可以正常编译,但是效率有所欠缺(下面会具体说到)。 class Word{String _name;int _cnt;public:Word() {_name = 0;_cnt = 0;}}; 上面这个程序的实现机制是:Word类的构造函数会先生成一个String类的临时对象(注意,_name是String类的对象),然后对该临时对象初始化。 然后通过赋值运算符将临时对象赋给_……