小编Tob*_*ght的帖子

我有一个像这样的数组:

Array
(
    [0] => Array
        (
            [0] => Title
            [1] => Date
            [2] =>  Text
            [3] =>  Category
            [4] => ID
            [5] => img

        )

    [1] => Array
        (
            [0] => title 1
            [1] => 2005-11-20
            [2] => "Text article"
            [3] => News
            [4] => 100
            [5] => <img scr="">
        )

    [2] => Array
        (
           [0] => title 2
            [1] => 2005-11-21
            [2] => "Text article"
            [3] => News
            [4] => 101
            [5] => <img scr="">
        )

    [3] => …

我正在编写一个程序,用于查找给定数字是否为阿姆斯壮数:

int main()
{
    int n,rem,sum=0;
    cout<<"Enter the Number for checking"<<endl;
    cin>>n;

    while(n!=0)
    {
        rem=n%10;
        sum=sum+(rem*rem*rem);
        n=n/10;
    }

    if(sum==n)
    {
        cout<<"Armstrong Number"<<endl;
    }
    else
    {
        cout<<"It's not a armstrong number";
    }

    return 0;
}

当我运行它时,无论输入如何,它总是报告"它不是一个非常强的数字".

我按如下方式更改了代码,并得到了正确的结果.但我不明白为什么我需要分配输入n1和执行操作 - 为什么我不能直接进行操作n？

int main()
{
    int n,rem,sum=0,n1;
    cout<<"Enter the Number for checking"<<endl;
    cin>>n;
    n1=n;

    while(n1!=0)
    {
        rem=n1%10;
        sum=sum+(rem*rem*rem);
        n1=n1/10;
    }

    if(sum==n)
    {
        cout<<"Armstrong Number"<<endl;
    }
    else
    {
        cout<<"It's not a armstrong number";
    }

    return 0;
}

当在varargs上下文中使用作用域枚举时,它被定义为作为其基础类型传递,如" 我可以使用枚举类值作为varargs函数的参数吗？ "中所解释的那样.据我所知,这是唯一的情况,其中一个范围的枚举将被隐式转换,就像一个无范围的枚举.

考虑这个程序:

enum Foo : char { F };
enum class Bar : char { B };

#include <cstdio>
int main()
{
    return !std::printf("%c\n", Foo::F)
        +  !std::printf("%c\n", Bar::B);
}

编译器(g++版本6.3.0)对a的第一个打印很满意Foo,但是当我传递时,抱怨Bar:

0.cpp: In function ‘int main()’:
0.cpp:10:34: warning: format ‘%c’ expects argument of type ‘int’, but argument 2 has type ‘Bar’ [-Wformat=]
         +  !printf("%c\n", Bar::B);
                                  ^

g++版本4.8.2没有抱怨这个,但g++6.3.0确实(这就是为什么它现在关注我).当存在实质性不匹配时,两个版本都抱怨第一次打印,例如使用%f或%s,或者如果我Foo改为使用long底层类型; 这就是我启用的原因-Wformat.

我知道警告不是标准一致性问题,我知道如何更改我的代码以解决这些问题(例如,在如何 …

我正在尝试创建一个类似于moreLinux 的程序，但没有一些参数。主要思想是我需要从文本文件中输出信息，并在命令字符串中包含一些参数。所以我的主要论点是more -d fileName。

我知道more输出 23 个带有文本的字符串，第 24 个是用户按下的space并获取另一个信息屏幕，但我需要考虑到用户可以更改控制台窗口的大小。

我正在尝试使用图书馆#include <sys/ioctl.h>，但它说我不能使用这样的库。我究竟做错了什么？

我的代码：

#include <iostream>\n#include <fstream>\n#include <vector>\n#include <string>\n#include <sys/ioctl.h>\n\nvoid printRecord(struct winsize w, std::vector<std::string> lines);\n\nint main(int argc, char *argv[]) {\n    struct winsize w;\n    ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);\n    std::ifstream readRecord;\n    std::string more("more");\n    std::vector<std::string> lines;\n\n    std::cout << "argc: " << argc << std::endl;\n    for (int i = 0; i < argc; i++)\n    {\n        std::cout << "Argument: " << i << " …

所以我在C中有这个代码,应该打印下面显示的地图.

printf ("(1)--------------------------------------------4T------5I        6P------7T-------------------------------------------(2)\n");
printf ("[%i]                                           [%i]     [%i]       [%i]     [%i]                                           [%i]\n", bs[1].leader, bs[4].leader, bs[5].leader, bs[6].leader, bs[7].leader, bs[2].leader);
printf (" \                                             |        \       /        |                                             / \n");
printf ("  \                                            |         \     /         |                                            /  \n");
printf ("   \                                           8T         \ 9T/         10T                                          /   \n");
printf ("    \                                         [ ]----------[ ]----------[ ]                                         /    \n");
printf ("     \                                         |            |            |                                         /     \n");
printf ("      \                                        |            |            |                                        /      \n");
printf ("      11P                                     12I          13I          14I                                     15P      \n");
printf ("      [ …

当我尝试制作电影时>>我收到错误C2679

没有运算符>>对应于这些操作数

我尝试包括标题

#include <iostream>
#include <string>

int Name();

void SignIn()
{
    std::cout << "enter your username : ";
    std::cin >> Name;
}

int main() {
    std::cout << "allo";
    SignIn();
    return 0;
}

最近我想出了一个想法，如何枚举参数包（脉冲）中的元素，我对这个解决方案很满意一段时间：

lastValue = 0.0; i = -1;
lastValue += (... + ((time <= endtimes[++i] && time >= delays[i]) ? static_cast<Pulses*>(fields[i])->operator()(time - delays[i]) : 0.0));

但是现在当我尝试使用 Clang 而不是 GCC 进行编译时，我收到了以下警告

警告：对“i”的多次未排序修改 [-Wunsequenced]

我读过几篇关于无序修改的帖子，但在他们的例子中，修改要么在表达式中发生两次，要么发生在“=”运算符的左侧。

另一方面，我的理解是参数包是按顺序评估的，所以......没有未排序的行为，对吗？或者我在这里完全错了，编译器总是对的？

以下代码在 VS 2013 中引发两个编译器错误：

1. 模板函数定义抛出

   错误 C2061：语法错误：标识符“ iterator”

2. 该模板函数的特化会抛出异常

   错误 C2912：显式特化“ double getFillIn<double,double>(fillInOptions,double,std::_Tree_iterator<std::_Tree_val<std::_Tree_simple_types<std::pair<const _Kty,_Ty>>>>,inputLoader *,va_list)”不是函数模板的特化

谁能解释一下为什么吗？我相当确定第二个错误只是第一个错误的结果，但我不明白为什么它无法找出该iterator标识符。

#include <map>

template <typename T> class table {
};

template <typename S, typename T>
void f(S s, std::map<S, table<T>*>::iterator it);

以下代码已在3个不同的编译器和3个不同的处理器上编译,并给出了2个不同的结果:

typedef unsigned long int u32;
typedef signed long long s64;
int main ()
{ u32 Operand1,Operand2;
  s64 Result;
  Operand1=95;
  Operand2=100;
  Result= (s64)(Operand1-Operand2);}

结果产生2个结果: -5 或者4294967291

我明白操作(Operand1-Operand2)是以32位无符号计算完成的,然后s64在第一种情况下正确完成符号扩展,但第二种情况没有正确完成.

我的问题是符号扩展是否可以通过编译器选项进行控制,或者它是依赖于编译器还是依赖于目标.

当我使用该pow()功能时,有时结果是一个.例如,这段代码产生124,但我知道5³应该是125.

#include<stdio.h>
#include<math.h>

int main(){
    int i = pow(5, 3);
    printf("%d", i);
}

为什么结果错了？