小编Nul*_*ull的帖子

我想写一个这样的模板.

template <char c,typename Options, 
   basic_string<class,class,class> Options::* member> 
   struct option_string;

但是我不断收到编译错误.我想知道如何编写一个带有三个选项的模板:a char,任何类和指向该类成员的指针,该类必须是特化basic_string.我想避免为每个专业化编写模板basic_string.

我的目标是创建一个通用的命令行选项库.以下是我想如何使用它.

class Options : public Command_Line_Options_Parser<Options> {
public:
  int integer = 0;
  float real_number = 0.0;
  bool boolean = false;
  bool make_true = false;
  bool make_false = true;
  std::string string;
  typedef Options O;
  typedef Command_Line_Options<
            option_int<'i',&O::integer>,
            option_float<'f',&O::real_number>,
            option_bool<'b',&O::boolean>,
            option_true<'t',&O::make_true>,
            option_false<'t',&O::make_true>,
            option_string<'s',&O::string>
           >
  option_list;
};

int main(int argc,char**argv ) {

  Options options;

  options.parse(argc,argv);
  std::cout << "integer : " << options.integer <<endl;
  std::cout << "real_number …

我有一个抽象基类和一对从该基类派生的类。我想引入一个static const成员，该成员在两个派生类之间具有不同的值，但对于给定派生类的所有实例具有相同的值。

我的代码使用分配给两个派生类之一的实例的基类指针，以便我可以通过更改基类指针分配的内容来轻松地在派生类之间切换。我希望能够以类似的方式使用基类获取派生类的常量值，以便我可以轻松地在两个类之间切换。期望的行为看起来像这样：

#include <iostream>
using namespace std;

// Abstract base class
class A {
    protected:
    int c; // this is really a constant and should also be static
    public:
    static int s;
    int get_c() const {
        return this->c;
    }
    virtual int foo() = 0; // makes this class abstract
};

class B : public A {
    public:
    static const int sb = 10;
    B() {
        this->c = 1;
    }
    int foo() {
        return -1;
    }
};

class …

我想避免使用switch声明,但我不知道如何.这是我的问题:

public class Person{
    String status;

    public void doSomething(){
        switch (status) {
        case "hungry":
                eatSomething();
                status = "full";
            break;
        case "full":
                doNothing();
                status = "hungry";
        default:
            break;
        }
    }}

我想做这样的事情:

    public abstract class Person{
        public abstract void doSomething();
}

public class HungryPerson extends Person{
        @Override
        public void doSomethink() {
            eatSomething();
        }
}


public class FullPerson extends Person{
    @Override
    public void doSomething() {
            doNothing();
    }   
}

问题是:如果Person他吃了一些东西,那么他必须是FullPerson,但如果我有一个参考,HungryPerson我怎么能改变它FullPerson？

int main(){
    Person person …

private void caseTextBox_TextChanged(object sender, EventArgs e)
        {
            var CTcase = caseTextBox.Text;
            caseTextBox.CharacterCasing = CharacterCasing.Upper;

            if (CTcase == "THRUHOLE") 
            {
                displayLabel3.Text = "0";
            }
            else if (CTcase == "EIAA")
            {
                displayLabel3.Text = "1";
            }
            else if (CTcase == "EIAB")
            {
                displayLabel3.Text = "2";
            }
            else if (CTcase == "EIAC")
            {
                displayLabel3.Text = "3";
            }
            else if (CTcase == "EIAD")
            {
                displayLabel3.Text = "4";
            }
            else
            {
                displayLabel3.Text = "error";
            }
        }

在每个语句中,有3个值可以等于显示正确的数字.但我不想写15 if/ else语句来使它工作.我尝试使用||,|,& …

我想限定它可用于任意类型(例如自定义常量float,double等).例如,假设我希望定义一个值为pi的常量.

显而易见的解决方案是使用#define pi 3.14159265359,但后来pi不会在命名空间中,我冒着名称冲突的风险.我没有使用C++ 14所以我不能使用变量模板.我能想到这样做的最好方法如下:

#include <iostream>

using namespace std;

namespace constants {
    template<typename T> T pi() {
        return 3.14159265359;
    }
}

int main() {
    float pitest = 0;
    pitest = constants::pi<float>();
    cout << pitest << endl;
    cout << constants::pi<long double>() << endl;
    cout << constants::pi<int>() << endl;

   return 0;
}

我现在可以在命名空间中定义这些常量,我可以根据需要使用任意(数字)类型.但是,至少有两个不良特征:

1. 它需要一个函数调用,这不是必需的(它只是一个常数!).
2. 我必须在函数调用中指定类型,即使函数返回已知类型的变量.例如,在上面的代码中,我必须使用pitest = constants::pi<float>();而不是简单,pitest = constants::pi();即使pitest显然是一个float.

有一个更好的方法吗？

例如,我们有以下简单代码:

#include "stdio.h"   

int main() {   
  int* pointer_to_check;
  printf("%x\n", pointer_to_check);
  return 0;
}

使用gcc,我们将在输出时得到零(对我而言,正常行为,因为指针与内存无关),但是clang为我们提供了一个真实的地址,可以在没有"分段错误"的情况下访问它.

我有两个问题:

1. 根据C标准(和C++)的正常行为是什么？
2. 为什么会这样？