[c++]类和对象常见题目详解

简介: [c++]类和对象常见题目详解


1.求1+2+3+…+n

题目来源:求1+2+3+…+n

题目描述:

 求1+2+3+…+n,要求不能使用乘除法、for、while、if、else、switch、case等关键字及条件判断语句(A?B:C)。

示例:

 输入:5

 返回值:15

分析:

 若是只看题目不管要求,这是一道非常简单的题目,我们有好几种方式可以得出最终结果,但加上题目限制条件,可能大多数博友都懵了。

我们来捋一捋:

 1、不能使用乘除法,等差数列求和公式不能用了。

 2、不能使用for、while,循环求解不能用了。

 3、不能使用switch、case和A?B:C,递归求解也不能用了。

思路:

这道题用常规的方式确实解决不了,因为题目把我们要用到的东西都限制死了。解决这道题之前我们需要知道:当一个对象被创建的时候,该对象会自动调用其默认构造函数。

 我们需要计算的是1-n这n个数的和,那么我们可以创建n个类对象,这样就可以调用n次构造函数,这就相当于代替了递归。每次需要被加的数都比上一次被加的数大一,我们可以借助于类的静态成员变量,在构造函数中设置该静态成员变量自增即可实现。特别注意,这里必须是静态成员变量,不能是普通的成员变量,因为每个对象被创建时都有属于自己的普通成员变量,而静态成员变量是属于整个类的,这样才能使得这n次调用构造函数时自增的是同一个变量,每个对象访问到的静态成员变量是同一个。同理,存储累加结果的变量也必须是静态成员变量。

class Add
{
public:
  Add() //构造函数
  {
    _num++;
    _ret += _num;
  }
  static int _num; //静态成员变量,存储正在累加的数字
  static int _ret; //静态成员变量,存储1+2+3+...+n的结果
};
//静态成员变量的定义
int Add::_num = 0;
int Add::_ret = 0;
class Solution 
{
public:
  int Sum_Solution(int n) 
  {
    //多个测试用例,可能会多次调用,做好初始化工作
    //防止第二个测试用例的结果是在第一个测试用例的基础上继续累加得到的
    Add::_num = 0;
    Add::_ret = 0;
    Add* p = new Add[n]; //为n个Add类对象申请空间(可调用n次构造函数)
    return Add::_ret; //返回1+2+3+...+n的结果
  }
};

代码中为了可以通过类名和类的访问限定符直接突破类域,进而访问到静态成员变量,于是把类的成员变量直接设置为了公有(public)。我们知道,将类的成员变量设置为公有是不安全的,对此,我们可以使用友元类来解决该问题。

class Add
{
  friend class Solution; //声明Solution是Add的有元类
public:
  Add() //构造函数
  {
    _num++;
    _ret += _num;
  }
private:
  static int _num; //静态成员变量,存储正在累加的数字
  static int _ret; //静态成员变量,存储1+2+3+...+n的结果
};
//静态成员变量的定义
int Add::_num = 0;
int Add::_ret = 0;
class Solution {
public:
  int Sum_Solution(int n) {
    //多个测试用例,可能会多次调用,做好初始化工作
    //防止第二个测试用例的结果是在第一个测试用例的基础上继续累加得到的
    Add::_num = 0;
    Add::_ret = 0;
    Add* p = new Add[n]; //为n个Add类对象申请空间(可调用n次构造函数)
    return Add::_ret; //返回1+2+3+...+n的结果
  }
};

代码中我们将Solution声明为Add的友元类,这样Solution类的成员函数就可以访问Add中的非公有成员了。但在某种意义上来说,使用友元是破坏了封装的,使得Solution类的独立性降低了。

 实际上,访问类中的静态成员变量最标准的方法是通过静态成员函数,我们可以通过定义静态成员函数来获取静态成员变量,或是对静态成员变量进行修改。

class Add
{
public:
  Add() //构造函数
  {
    _num++;
    _ret += _num;
  }
  static void Init() //对静态成员变量进行初始化
  {
    _num = 0;
    _ret = 0;
  }
  static int Getret() //获取静态成员变量_ret
  {
    return _ret;
  }
private:
  static int _num; //静态成员变量,存储正在累加的数字
  static int _ret; //静态成员变量,存储1+2+3+...+n的结果
};
//静态成员变量的定义
int Add::_num = 0;
int Add::_ret = 0;
class Solution 
{
public:
  int Sum_Solution(int n) 
  {
    //多个测试用例,可能会多次调用,做好初始化工作
    //防止第二个测试用例的结果是在第一个测试用例的基础上继续累加得到的
    Add::Init();
    //Add arr[n];
    Add* p = new Add[n]; //为n个Add类对象申请空间(可调用n次构造函数)
    return Add::Getret(); //返回1+2+3+...+n的结果
  }
};

2.计算一年的第几天

题目来源:计算日期到天数转换

题目描述:

 根据输入的日期计算是这一年的第几天。

示例:

 输入:2021 7 18

 输出:199

思路:

 计算某日期是该年的第几天,也就是计算从该年的1月1日到该日期一共有多少天。计算总天数时,我们可以先按照平年的天数进行计算,这样一来每个月的天数都是固定的,然后再判断所给日期是否为3月及以上,因为此时才需要考虑是否为闰年,若日期为3月及以上并且为闰年,则将之前得到的总天数+1作为最终的总天数。

#include <iostream>
using namespace std;
int main()
{
  int year, month, day;
  cin >> year >> month >> day; //输入日期
  int daysArray[13] = { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 }; //daysArray[i]表示1月-i月的总天数(默认2月为28天)
  int totalDay = daysArray[month - 1] + day; //总天数
  if ((month > 2) && ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))) //如果所给日期为3月及以上,并且该年为闰年
  {
    totalDay += 1; //总天数+1(2月29日)
  }
  cout << totalDay << endl; //输出总天数,即该日期为该年的第几天
  return 0;
}

实现二:

#include <iostream>
using namespace std;
int month[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int main() 
{
    int y, m, d;
    cin >> y >> m >> d;//输入年月日
    int sum = 0;
    for (int i = 1; i < m; i++) 
    { //加每月的天数
        sum += month[i - 1];
    }
    sum += d; //加日数
    if (((y % 4 == 0 && y % 100 != 0) || y % 400 == 0) &&
            m > 2) //闰年并且月份大于2,则加一
        sum++;
    cout << sum << endl;
    return 0;
}

3.日期差值

题目来源:日期差值

题目描述:

 有两个日期,求两个日期之间的天数,如果两个日期是连续的我们规定它们之间的天数为两天。

示例:

 输入:19700101

    20210718

 输出:18827

思路:

 根据所给的两个日期,分别得到两个日期的年、月、日,然后先计算出这两个日期年相差的天数,得到的值减去第一个日期当年的天数,再加上第二个日期当年的天数即可,但是题目规定:如果两个日期是连续的,那么题目之间的天数为两天。这意味着我们需要计算的日期差值为闭区间 [date1, date2],所以输出结果时需要再加上1。

//日期差值
#include <iostream>
using namespace std;
//判断是否为闰年
bool IsLeapYear(int year)
{
  return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}
int main()
{
  int date1, date2; //存储两个日期
  int year1, year2, month1, month2, day1, day2; //存储两个日期的年、月、日
  int ret = 0; //存储两个日期的差值
  int dayArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; //dayArray[i]代表i月的天数(平年)
  while (cin >> date1 >> date2) //多组测试数据
  {
    //确保第一个日期比第二个日期小
    if (date1 > date2)
    {
      int tmp = date1;
      date1 = date2;
      date2 = tmp;
    }
    //根据两个日期得到其年、月、日
    year1 = date1 / 10000, year2 = date2 / 10000;
    day1 = date1 % 100, day2 = date2 % 100;
    month1 = date1 % 10000 / 100, month2 = date2 % 10000 / 100;
    //计算年相差的天数
    for (int year = year1; year < year2; year++)
    {
      if (IsLeapYear(year))
        ret += 366;
      else
        ret += 365;
    }
    auto getCurYearDays = [&dayArray](int year, int month, int day)->int{
      int total = 0;
      for (int i = 1; i < month; i++) 
      {
        total += dayArray[i];
        if (i == 2 && IsLeapYear(year))
          total++;
      }
      return total + day;
    };
    //减去date1当年的天数
    int days1 = getCurYearDays(year1, month1, day1);
    ret -= days1;
    //加上date2当年的天数
    int days2 = getCurYearDays(year2, month2, day2);
    ret += days2;
    ret++; //结果为闭区间[date1, date2],所以需要再加1
    cout << ret << endl;
  }
  return 0;
}

4.打印日期

题目来源:打印日期

题目描述:

 给出年份m和一年中的第n天,计算出第n天是几月几号。

示例:

 输入:2021 100

 输出:2021-04-10

思路:

 根据得到的年份判断该年是否为闰年,从而得到该年每月的准确天数。设置月份从1月开始,判断所给总天数是否大于该年该月的总天数,若大于,则将总天数减去该月的总天数后作为新的总天数,然后将月份加一,继续进行判断;若小于,则结束判断,输出日期即可。

#include <iostream>
using namespace std;
int main()
{
  int year, day;
  int dayArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; //dayArray[i]代表i月的天数(平年)
  while (cin >> year >> day) //多组测试数据
  {
    int month = 1; //month从1月开始
    if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0)) //判断该年是否为闰年
      dayArray[2] += 1; //闰年2月为29天
    //使日期合法
    while (day > dayArray[month])
    {
      day -= dayArray[month];
      month++;
    }
    printf("%d-%02d-%02d\n", year, month, day); //按格式输出
  }
  return 0;
}

5. 日期累加

题目来源:日期累加

题目描述:

 设计一共程序能计算一个日期加上若干天后是什么日期。

输入描述:

 输入第一行表示样例个数m,接下来m行每行四个整数分别表示年月日和累加的天数。

输出描述:

 输出m行每行按yyyy-mm-dd的格式输出。

示例:

 输入:2

    2021 7 18 100

    2021 1 1 100

 输出:2021-10-26

    2021-04-11

思路:

 先将需要累加的天数加到“日”上,然后通过不断的迭代使得日期合法,迭代过程如下:判断“日”是否大于该年该月的总天数,若大于,则将“日”减去该月的总天数后作为新的“日”,然后将月份加一,继续进行判断;若小于,则结束判断,输出日期即可。需要注意:每次月份加一后需要判断“年”是否需要进位,若需要进位还需判断进位后的年是否为闰年。

#include <iostream>
using namespace std;
//判断是否为闰年
bool IsLeapYear(int year)
{
  return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0);
}
int main()
{
  int m, year, month, day, n;
  int dayArray[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; //dayArray[i]代表i月的天数(平年)
  cin >> m; //读取样例个数
  for (int i = 0; i < m; i++)
  {
    cin >> year >> month >> day >> n; //读取年、月、日和需要累加的天数
    if (IsLeapYear(year))
      dayArray[2] = 29; //闰年2月设置为29天
    day += n; //先将需要累加的天数加到“日”上
    //使日期合法
    while (day > dayArray[month])
    {
      day -= dayArray[month];
      month++;
      if (month == 13) //“年”需要进位
      {
        year++;
        month = 1;
        //判断新的一年是否为闰年
        if (IsLeapYear(year))
          dayArray[2] = 29; //闰年2月设置为29天
        else
          dayArray[2] = 28; //平年2月设置为28天
      }
    }
    printf("%d-%02d-%02d\n", year, month, day); //按格式输出
  }
  return 0;
}
相关文章
|
4月前
|
人工智能 机器人 编译器
c++模板初阶----函数模板与类模板
class 类模板名private://类内成员声明class Apublic:A(T val):a(val){}private:T a;return 0;运行结果:注意:类模板中的成员函数若是放在类外定义时,需要加模板参数列表。return 0;
106 0
|
4月前
|
存储 编译器 程序员
c++的类(附含explicit关键字,友元,内部类)
本文介绍了C++中类的核心概念与用法,涵盖封装、继承、多态三大特性。重点讲解了类的定义(`class`与`struct`)、访问限定符(`private`、`public`、`protected`)、类的作用域及成员函数的声明与定义分离。同时深入探讨了类的大小计算、`this`指针、默认成员函数(构造函数、析构函数、拷贝构造、赋值重载)以及运算符重载等内容。 文章还详细分析了`explicit`关键字的作用、静态成员(变量与函数)、友元(友元函数与友元类)的概念及其使用场景,并简要介绍了内部类的特性。
181 0
|
6月前
|
编译器 C++ 容器
【c++11】c++11新特性(上)(列表初始化、右值引用和移动语义、类的新默认成员函数、lambda表达式)
C++11为C++带来了革命性变化,引入了列表初始化、右值引用、移动语义、类的新默认成员函数和lambda表达式等特性。列表初始化统一了对象初始化方式,initializer_list简化了容器多元素初始化;右值引用和移动语义优化了资源管理,减少拷贝开销;类新增移动构造和移动赋值函数提升性能;lambda表达式提供匿名函数对象,增强代码简洁性和灵活性。这些特性共同推动了现代C++编程的发展,提升了开发效率与程序性能。
209 12
|
7月前
|
编译器 C++
类和对象(中 )C++
本文详细讲解了C++中的默认成员函数,包括构造函数、析构函数、拷贝构造函数、赋值运算符重载和取地址运算符重载等内容。重点分析了各函数的特点、使用场景及相互关系,如构造函数的主要任务是初始化对象,而非创建空间;析构函数用于清理资源;拷贝构造与赋值运算符的区别在于前者用于创建新对象,后者用于已存在的对象赋值。同时,文章还探讨了运算符重载的规则及其应用场景,并通过实例加深理解。最后强调,若类中存在资源管理,需显式定义拷贝构造和赋值运算符以避免浅拷贝问题。
|
7月前
|
存储 编译器 C++
类和对象(上)(C++)
本篇内容主要讲解了C++中类的相关知识,包括类的定义、实例化及this指针的作用。详细说明了类的定义格式、成员函数默认为inline、访问限定符(public、protected、private)的使用规则,以及class与struct的区别。同时分析了类实例化的概念,对象大小的计算规则和内存对齐原则。最后介绍了this指针的工作机制,解释了成员函数如何通过隐含的this指针区分不同对象的数据。这些知识点帮助我们更好地理解C++中类的封装性和对象的实现原理。
|
7月前
|
编译器 C++
类和对象(下)C++
本内容主要讲解C++中的初始化列表、类型转换、静态成员、友元、内部类、匿名对象及对象拷贝时的编译器优化。初始化列表用于成员变量定义初始化,尤其对引用、const及无默认构造函数的类类型变量至关重要。类型转换中,`explicit`可禁用隐式转换。静态成员属类而非对象,受访问限定符约束。内部类是独立类,可增强封装性。匿名对象生命周期短,常用于临时场景。编译器会优化对象拷贝以提高效率。最后,鼓励大家通过重复练习提升技能!
|
8月前
|
编译器 C++ 开发者
【C++篇】深度解析类与对象(下)
在上一篇博客中,我们学习了C++的基础类与对象概念,包括类的定义、对象的使用和构造函数的作用。在这一篇,我们将深入探讨C++类的一些重要特性,如构造函数的高级用法、类型转换、static成员、友元、内部类、匿名对象,以及对象拷贝优化等。这些内容可以帮助你更好地理解和应用面向对象编程的核心理念,提升代码的健壮性、灵活性和可维护性。
|
7月前
|
设计模式 安全 C++
【C++进阶】特殊类设计 && 单例模式
通过对特殊类设计和单例模式的深入探讨,我们可以更好地设计和实现复杂的C++程序。特殊类设计提高了代码的安全性和可维护性,而单例模式则确保类的唯一实例性和全局访问性。理解并掌握这些高级设计技巧,对于提升C++编程水平至关重要。
139 16
|
8月前
|
编译器 C语言 C++
类和对象的简述(c++篇)
类和对象的简述(c++篇)
|
7月前
|
安全 C++
【c++】继承(继承的定义格式、赋值兼容转换、多继承、派生类默认成员函数规则、继承与友元、继承与静态成员)
本文深入探讨了C++中的继承机制,作为面向对象编程(OOP)的核心特性之一。继承通过允许派生类扩展基类的属性和方法,极大促进了代码复用,增强了代码的可维护性和可扩展性。文章详细介绍了继承的基本概念、定义格式、继承方式(public、protected、private)、赋值兼容转换、作用域问题、默认成员函数规则、继承与友元、静态成员、多继承及菱形继承问题,并对比了继承与组合的优缺点。最后总结指出,虽然继承提高了代码灵活性和复用率,但也带来了耦合度高的问题,建议在“has-a”和“is-a”关系同时存在时优先使用组合。
386 6