小编JeJ*_*eJo的帖子

我正在尝试创建一个程序,按照特定的数字系列条件(1-1-3-6-8-8-10-20)打印前200个元素,但不显示只有200个元素显示802.我假设是因为"for"循环中的代码,但我花了很多时间考虑如何减少代码到工作,我想不出别的.我很沮丧,需要你的帮助.

练习是在代码评论上

//Print the following numerical series 1-1-3-6-8-8-10-20  until 200
#include <stdafx.h>
#include <iostream>
#include <stdlib.h>
using namespace std;

int main()
{
    int Num1=200, z = 0, x = 1, y = 1;

    cout << "\n\n1,";
    cout << " 1,";

    for (int i = 1; i <= Num1; i++)
    {
        z = y + 2;
        cout << " " << z << ","; //It will print 3
        z = z * 2;
        cout << " " << z << ",";//It …

我正在使用C++ Primer一书学习C++.

在1.4.3节中,给出了以下关于读取未知数量输入的示例代码.

#include <iostream>
int main()
{
  int sum = 0, value = 0;
  // read until end-of-file, calculating a running total of all values read
  while (std::cin >> value)
  sum += value; // equivalent to sum = sum + value
  std::cout << "Sum is: " << sum << std::endl;
  return 0;
}

根据书中我们给出的输入3 4 5 6,输出将是Sum is: 18

但是当我在我的计算机上尝试这个(带有mingW的Windows 10)时,代码并没有结束.即使我输入换行符,它也会继续询问输入.它仅在我输入非int输入时才有效f.

这是预期的吗？如果是,是否有任何代码在输入换行符后停止？

我对c ++很陌生,而且我已经学过python,所以这么早就陷入困境是非常令人沮丧的.

感谢致敬.

我正在乱搞一个指针向量的指针

std::vector<int*>* MyVector;

我试图使用这两种方法访问:

MyVector->at(i);    //This works
MyVector[i]         //This says "Expression must be a pointer to a complete object type"

根据我的理解,向量[] operator和at方法之间的区别在于at方法进行了额外的边界检查,所以我的问题是为什么at方法成功访问元素而[] operator不是？

编辑:

整个代码在这里

#include <vector>
#include <iostream>

std::vector<int*>* MyVector;

int main()
{
    MyVector = new std::vector<int*>;
    MyVector->push_back(new int(5));


    for (unsigned int i = 0; i < MyVector->size(); i++)
    {
        delete MyVector->at(i); //This works
        delete MyVector[i];     //This says "Expression must be a pointer to a complete object type
    }

    system("pause");
}

我想像这样添加一个延迟：

std::cout << "loading..." << endl;
//add delay here

是否有某种delay功能或 delay库

我试图学习C ++中的存储桶排序算法，发现以下代码：

// C++ program to sort an array using bucket sort 
#include <iostream> 
#include <algorithm> 
#include <vector> 
using namespace std;

// Function to sort arr[] of size n using bucket sort 
void bucketSort(float arr[], int n)
{
    // 1) Create n empty buckets 
    vector<float> b[n];

    // 2) Put array elements in different buckets 
    for (int i = 0; i < n; i++)
    {
        int bi = n * arr[i]; // Index in bucket 
        b[bi].push_back(arr[i]);
    }

    // 3) Sort individual …

我具有以下向量值：[2, 3, 7]。

我想输出向量的乘积，如中所示2*3*7 = 42。

我为此写了一些代码，但是似乎没有用。我是C ++的新手，因此在给定任何大小的数值矢量的情况下，我不确定如何获取矢量值的乘积。

#include <bits/stdc++.h>

int main()
{
    int n;
    cin >> n;
    vector<int> vec;
    while (n--) 
    {
        int temp;
        cin >> temp;
        vec.push_back(temp);
    }
    int total = 1;
    total *= vec;
    cout << vec << endl;
    return 0;
}

对于下面的代码，我不断收到此错误。

在阅读此，我相信我的错误是it++在我的for循环，我试图与更换next(it, 1)，但它并没有解决我的问题。

我的问题是，迭代器是给我问题的那个吗？

#include <iostream>
#include <vector>
#include <stack>
#include <set>
using namespace std;

struct Node
{
    char vertex;
    set<char> adjacent;
};


class Graph
{
public:
    Graph() {};
    ~Graph() {};

    void addEdge(char a, char b)
    {
        Node newV;
        set<char> temp;
        set<Node>::iterator n;

        if (inGraph(a) && !inGraph(b)) {
            for (it = nodes.begin(); it != nodes.end(); it++)
            {
                if (it->vertex == a)
                {
                    temp = it->adjacent;
                    temp.insert(b);
                    newV.vertex = b;
                    nodes.insert(newV);
                    n = nodes.find(newV);
                    temp …

在Python中，可以存储具有不同数量参数的函数指针，并将参数存储在列表中，然后解压列表并调用该函数，如下所示：

def Func(x1, x2):\n   return x1+x2\nArgList = [1.2, 3.22]\nMyClass.Store(Func)\nMyClass.FuncPtr(*ArgList)\n

在c++中是否可以做类似的事情？

例如，将具有可变数量的输入和值的函数存储在 a 中，std::vector并通过该向量调用函数指针？

我不想将参数列表定义为向量。

我编写了一个Fraction类来处理Fraction对象和重载等，我需要将实现与方法的定义分开，但是当涉及到类的构造函数时，我收到了重新定义错误Fraction。

来自Fraction.h 的代码片段

class Fraction
{
private:
   int calcGCD(int n1, int n2) const;
   int compare(const Fraction& fraction) const;
   int m_numerator;
   int m_denominator;
public:
   Fraction(int numerator = 0, int denominator = 1) : m_numerator(numerator), m_denominator(denominator);
   Fraction(const Fraction& fraction) : m_numerator(fraction.numerator()), m_denominator(fraction.denominator());
   Fraction(const Fraction& orig);
};

#include "Fraction.h"

Fraction::Fraction(int numerator, int denominator) 
   : m_numerator(numerator), m_denominator(denominator)
{}

Fraction::Fraction(const Fraction& fraction)
   : m_numerator(fraction.numerator()), m_denominator(fraction.denominator())
{}

Fraction.h:26:5: error: 'Fraction::Fraction(const Fraction&)' cannot be …