小编Mut*_*thm的帖子

我试图理解C++中的基础过程,它允许我们在C++中形成以下表达式:

cout << "Hello," << "World" << a + b;

根据我的理解,首先,插入运算符将ostream对象cout和字符串文字"Hello"作为操作数,表达式返回一个类型,cout因此cout现在是下一个字符串文字的类型,最后也是表达式的类型a + b.

我无法理解这个过程的技术细节,我理解参与是否允许我们这样做？

假设我f在C++中使用以下3个签名定义了一些函数:

void f(int x) {}
void f(int& x) {}
void f(const int& x) {}

这些函数可以共存,因为它们的参数类型不同.

现在我运行以下代码:

int main {
   int i = 3;
   const int ci = 4;

   f(3);
   f(i);
   f(ci);
}

在这种特定情况下,C++如何知道要调用哪个重载函数？在C++中编写重载函数的一般规则(最佳实践？)是什么,以避免歧义.当前的C++ 14标准是否指定了任何特定的规则？

我有以下要并行化的代码:

int ncip( int dim, double R)
{   
    int i;
    int r = (int)floor(R);
    if (dim == 1)
    {   
        return 1 + 2*r; 
    }
    int n = ncip(dim-1, R); // last coord 0

    #pragma omp parallel for
    for(i=1; i<=r; ++i)
    {   
        n += 2*ncip(dim-1, sqrt(R*R - i*i) ); // last coord +- i
    }

    return n;
}

当我尝试并行化for循环时,没有openmp运行的程序执行时间是6.956s,我的执行时间大于3分钟(这是因为我自己结束了).在并行化此代码方面我做错了什么？

第二次尝试

    int ncip( int dim, double R)
{   
int i;
int r = (int)floor( R);
if ( dim == 1)
{   return …

Java中的数组是一个对象.因此,如果我有一个2D数组,double[][] matrix = new double[5][5]那么该数组的每一行都是一个引用内存中单维数组的对象.根据我的理解,一旦在java中设置了数组大小,就无法更改.所以让我声明一个1D数组double[] d = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}然后我被允许设置,matrix[1] = d以便第1行现在指向内存中的d.我似乎没有真正修复数组大小.我可以声明matrix为任何大小,只需将引用更改为指向不同大小的数组.如果matrix尺寸固定为5 x 5,为什么我可以这样做呢？

我在 C++ 中输入了一个基本示例，其中我尝试将一个数字以十六进制形式打印到屏幕上，如下所示：

#include <iostream>
#include <iomanip>

int main()
{
    unsigned number {314};

    auto flags {std::ios::showbase | std::ios::hex};
    std::cout.setf(flags);

    // expected output: 0x13A
    std::cout << number << std::endl;

    std::cout.unsetf(flags);

   // expected output: 314
   std::cout << number << std::endl;

   return 0;
}

但是，该数字永远不会以十六进制格式显示。我是否正确设置了标志？

这是完整的问题陈述：

给定长度为 n 的绳子，您需要找到
可以制作的最大绳子数，使得对于
给定的三个值 a、b、c，每根绳子的长度都在集合 {a, b, c } 中

我知道可以通过动态规划来实现最优解，但是，我还没有学过这个主题，我需要递归地解决这个问题。对于递归，主要的事情是确定子问题，而这正是我主要遇到的困难。谁能给我一个直观的方式来思考这个问题？如果有意义的话，有点像递归的更高层次的描述。有没有与此类似的更简单的问题我可以先尝试来帮助我解决这个问题？

提前致谢。

我的主要职能有以下几行。

BlackScholesPricer* option = new EuropeanCallOption(105, 100, 0.5, 0.1, 0.36, 0);
PricingUtil::mesh_pricer<EuropeanCallOption>(option, 105, 150, 5);

这是有问题的功能。

template <typename OptionType>
std::vector<double> PricingUtil::mesh_pricer(BlackScholesPricer* option, 
std::size_t lower_bound, std::size_t upper_bound, std::size_t mesh_size) {

OptionType financial_instrument(*option);
std::vector<double> generated_prices;

for (std::size_t price = lower_bound; price <= upper_bound; price += mesh_size) {

    financial_instrument.asset_price(price);
    generated_prices.push_back(financial_instrument.price());

}

return generated_prices;

}

我想将派生类BlackScholesPricer传递给该函数，但是我不想修改传递给该函数的对象，因此我试图创建它的副本。我收到一条错误消息，指出不能将BlackScholes *类型的对象转换为const EuropeanCallOption＆（这是我想的复制构造函数）。

解决问题的最有效方法是什么，或者甚至更好的方法是，除了我以外，在这种情况下采取的最佳方法是什么？

为什么在C中这被认为是非法的？

#include <stdio.h>
int main()
{
    int integer;
    char character;
    float floatingPoint;

    scanf(" %d %c %f", integer, character, floatingPoint);

    return 0;
}

上面的代码在cc编译器下生成以下错误消息.

cc Chapter2ex1.c
Chapter2ex1.c: In function ‘main’:
Chapter2ex1.c:8:5: warning: format ‘%d’ expects argument of type ‘int *’, but argument 2 has type   ‘int’ [-Wformat=]
 scanf(" %d%c%f", integer, character, floatingPoint);
 ^
Chapter2ex1.c:8:5: warning: format ‘%c’ expects argument of type ‘char *’, but argument 3 has type ‘int’ [-Wformat=]
Chapter2ex1.c:8:5: warning: format ‘%f’ expects argument of type ‘float …

我Array班上有以下数据成员.

private: Point* m_data; int m_array_size; 我想为这个类实现一个拷贝构造函数,如下所示:

Array(const Array &a)

在实施内部.我有以下内容.

Array::Array(const Array &a) : m_array_size(a.m_array_size) {
    delete[] m_data;
    m_data = new Point[m_array_size]

    for(int i = 0; i < m_array_size; i++) {
        m_data[i] = a.m_data[i];
    }
}

我收到一个分段错误错误,我怀疑是由于delete[]操作.但是,我不知道我在这里做错了什么.我只是释放与之关联的内存m_data并重新分配新内存.

我不确定以下内容是否相关,但由于我在Array类中使用自定义对象作为数据成员,因此这是来自该类的重载赋值运算符.

Point& Point::operator = (const Point &source) {

    if(this == &source) return *this;

    m_x = source.m_x;
    m_y = source.m_y;

    return *this;
}

我有一个非常简单的Color类实现如下:

using System;
namespace HelloWorld
{
    internal class Color
    {
        private byte red;
        private byte green;
        private byte blue;
        private byte alpha;

        public Color(byte red, byte green, byte blue, byte alpha)
        {
            this.red = red;
            this.green = green;
            this.blue = blue;
            this.alpha = alpha;
        }

        public Color(byte red, byte green, byte blue)
        {
            this.red = red;
            this.green = green;
            this.blue = blue;
            this.alpha = 255;
        }

        public byte Red { get; set; }
        public byte Green { get; …