小编ste*_*fan的帖子

今天我浏览了一些源代码(这是一个解释软件框架使用的示例文件)并发现了很多这样的代码:

int* array = new int[10]; // or malloc, who cares. Please, no language wars. This is applicable to both languages
for ( int* ptr = &(array[0]); ptr <= &(array[9]); ptr++ )
{
   ...
}

所以基本上,他们已经完成了"获取位于地址的对象的地址array + x".

通常我会说,这是明显的愚蠢,因为写作array + 0或array + 9直接做同样的事情.我甚至总是会将这样的代码重写为size_t for循环,但这是一个风格问题.

但过度使用这个让我思考:我是否遗漏了一些明显的东西或者隐藏在语言黑暗角落里的东西？

对于任何想要查看原始源代码的人来说,有了它所有令人讨厌的gotos,mallocs当然还有这个指针的东西,请随时在线查看.

当我调试和优化我的一个 C/C++ 项目时，我经常禁用和启用-p -g -pg我的 Makefile 中的分析标志和一些优化标志，以便更好地了解发生了什么。

但是，GNU make没有检测到这种变化，也没有进行重新编译。

如何在不手动执行make clean?

我被指派在不使用归约子句的情况下实现归约变量的想法。我设置了这个基本代码来测试它。

int i = 0;
int n = 100000000;
double sum = 0.0;
double val = 0.0;
for (int i = 0; i < n; ++i)
{
    val += 1;
}
sum += val;

所以最后sum == n。

每个线程应该将val设置为私有变量，然后对sum的加法应该是线程收敛的关键部分，例如

int i = 0;
int n = 100000000;
double sum = 0.0;
double val = 0.0;
#pragma omp parallel for private(i, val) shared(n) num_threads(nthreads)
for (int i = 0; i < n; ++i)
{
    val += 1;
}
#pragma omp …

根据c ++语法,const int* const p意味着p指向它并且它的值不能被重写.但是今天我发现如果我这样编码:

void f(const int* const p)  
 { 
     char* ch = (char*) p;
     int* q = (int*) ch;
     (*q) = 3;  //I can modify the integer that p points to
 }

在这种情况下,关键字"const"将失去它的效果.使用"const"有什么意义吗？

我有以下代码：

 char* gen()
 {
     char out[256];
     sprintf(out, ...); // you don't need to know what's in here I don't think

     return out;
 }

当我尝试编译时出现此错误：

ERROR: function returns address of local variable

我试过有这个回报率char[]，并char没有运气。我错过了什么吗？

记录http://en.cppreference.com/w/cpp/memory/unique_ptr/reset,

void reset( pointer ptr = pointer() );

template< class U > 
void reset( U ) = delete;

void reset( std::nullptr_t p );

1)给定current_ptr,由其管理的指针按*this以下顺序执行以下操作:保存当前指针的副本old_ptr = current_ptr; 用参数覆盖当前指针current_ptr = ptr; 如果旧指针非空,则删除以前管理的对象if(old_ptr != nullptr) get_deleter()(old_ptr).

2)在动态数组的特化中,std::unique_ptr<T[]>提供此模板成员是为了防止使用reset()指向派生的指针(这将导致数组的未定义行为).

3)在动态数组的专门化中std::unique_ptr<T[]>,第三个重载是必要的,以允许重置nullptr(否则模板重载将禁止).相当于 reset(pointer())

现在这reset(nullptr)相当于reset(pointer()),为什么后者存在？

如果我想重置一个数组形式unique_ptr,为什么我不能只使用rest(pointer())？

我需要一种方法来获得目标编译器体系结构上可用的最大类型.我希望有一个定义:

#if defined PLATFORM_32BIT
#define LARGEST_UNSIGNED_TYPE uint32_t
#elseif defined PLATFORM_64BIT
#define LARGEST_UNSIGNED_TYPE uint64_t
#endif

是否有标准的C++方法来实现这一目标？或者我需要自己动手？

我正在编写一个小编译时助手,让我确定是否存在具有特定签名的函数(现在:没有名称空间或类成员函数)(例如__builtin_pop_count,哪个广泛传播,但不保证在任何平台上都可用) .

对于固定数量的参数,这很容易做到:

template <typename ReturnType, typename ArgumentType, typename = void>
struct Exists : std::false_type // Base case
{
};

template <typename T>
using void_t = void;

template <typename T>
using return_t = decltype(foo(std::declval<T>())); // here it is hidden: foo, although this symbol is never declared!

// specialization (compiler has to pick this one if no substitution failure in return_t
template <typename ReturnType, typename ArgumentType>
struct Exists<ReturnType, ArgumentType, void_t<return_t<ArgumentType>>>
  : std::is_same<return_t<ArgumentType>, ReturnType> // check the return type
{ …

我需要计算给定日期的天数。一年有 366 天。然而，每个月都有不同的值，我必须分配这些值。有没有比我正在做的更快的方法来做到这一点？

#include<iostream>
using namespace std;
int main()
{
   int day, month, year, dayNumber;

   cout<< "Please enter the month, by numerical value:";
   cin>> month;
   cout<<"Please enter the day, by numerical value:";
   cin>> day;
   cout<<"Please enter the year, by numerical value:";
   cin>> year;
   if (month == 1)
   {
      dayNumber= day;
      cout<< "Month;" << '\t'<< month << '\n'
          << "Day:"<<'\t'<< day<< '\n'
          << "Year:"<<'\t'<< year<<'\n'
          << "Day Number:"<< '\t'<< dayNumber<< endl;
   }
   else if(month==2)
   {
      dayNumber= day+31; 
   }
}

我想测试一个简单的事情,如下所示:

#include <iostream>
#include <boost/variant.hpp>

template<typename T1,typename T2>
std::ostream& operator<<(std::ostream& os, const std::pair<T1,T2>& dt){
    os << dt.first << dt.second;
    return os;
}



int main(){

   boost::variant<int, std::pair<int,int>, bool> v;
   v = std::pair<int,int>(3,3);
   std::cout << v << std::endl;

}

这实际上应该有效,因为对于普通类型,int, double等等,它会编译. boost::variant有一个打印机vistor,它在内部使用它来输出内容到流.实际上这无法编译,但我真的不知道这个问题:

代码在这里失败:在variant_io.hpp中

template <typename OStream>
class printer
    : public boost::static_visitor<>
{
private: // representation

    OStream& out_;

public: // structors

    explicit printer(OStream& out)
        : out_( out )
    {
    }

public: // visitor interface

    template <typename T>
    void operator()(const T& …