Drottarutarnum

попробуйте

var command = @"C:\Program Files (x86)\TestProg\TestProg.exe -c -d";

Drottarutarnum,

дело в том, что там куча переменных из вне которые меняют команду, я не могу выполнять файл

это вопрос только ваших умений работы со строками

Александр Юдаков,

То, что вы описываете, называется Kiosk mode.
https://docs.microsoft.com/en-us/windows/configura...

<style name="AppTheme" parent="YourTheme">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
        <item name="materialButtonStyle">@style/systemButtonStyle</item> <!-- если используете MaterialComponents -->
        <item name="buttonStyle">@style/systemButtonStyle</item> <!-- если используете AppCompat  -->
 </style>

<style name="systemButtonStyle" parent="Widget.MaterialComponents.Button">
      <item name="android:background">@drawable/roundedbutton</item>
</style>

drawable/roundedbutton.xml

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android" 
android:shape="rectangle">
    <solid android:color="#ff0000" />
    <corners android:radius="8dp"/>
</shape>

#include <iostream>

using namespace std;

template<typename DataType>
struct Data {
  static const DataType m_default_value;
  DataType m_data;

  Data() : m_data(m_default_value) {}
  
  Data(const DataType& value) : m_data(value) {}

  operator DataType () const {
    return m_data;
  }

  void operator = (const DataType& _data) {
    m_data = _data;
  }
};

template <> Data<double>::m_default_value = 0.;

int main(int argc, char** argv) 
{
    Data<double> data = 3.14159;
    cout << data << endl;
    return EXIT_SUCCESS;
}

Для неизменяемых данных я придумал.

#include <iostream>

template <class T>
struct Array
{
    const size_t size;
    const T* const data;

    const T* begin() const { return data; }
    const T* end() const { return data + size; }

    constexpr Array(const std::initializer_list<T>& x)
        : size(x.size()), data(x.begin()) {}
};

using Row = Array<int>;
using Matrix = Array<Row>;

Matrix mtx = {
  {1, 2, 3 },
  { 10, 20, 30, 40, 50 },
  {},
  { 100 }
};

int main()
{
    for (auto& u : mtx) {
        for (auto& v : u) {
            std::cout << v << ' ';
        }
        std::cout << std::endl;
    }
    return 0;
}

Для изменяемых данных пока вышло только так.

#include <iostream>

// Изменяемый вариант
template <class T>
struct Array2
{
    const size_t size;
    T* const data;

    T* begin() { return data; }
    T* end() { return data + size; }
    const T* begin() const { return data; }
    const T* end() const { return data + size; }
    T& operator[](int i) { return data[i]; }

    template <size_t N>
    constexpr Array2(T (&x)[N])
        : size(N), data(x) {}
};

using Row2 = Array2<int>;
using Matrix2 = Array2<Row2>;

int main()
{
    int i;
    std::cin >> i;

    int row1[] = { 1, i, 3 };
    int row2[] = { 10, 2*i, 30, 3*i, 50 };
    int row3[] = { 13 };
    int row4[] = { 100 };

    Row2 mtx[] = { row1, row2, row3, row4 };

    mtx[1][4] = i * 6;

    for (auto& u : mtx) {
        for (auto& v : u) {
            std::cout << v << ' ';
        }
        std::cout << std::endl;
    }
    return 0;
}

Можно использовать конвертер i:InvokeCommandAction из System.Windows.Interactivity.

1) Добавить сборку System.Windows.Interactivity с помощью добавления ссылки (она в списке расширений).

2) Добавить указанную сборку в xaml:

xmlns:i="clr-namespace:System.Windows.Interactivity;assembly=System.Windows.Interactivity"

3) Использовать i:EventTrigger и i:InvokeCommandAction:

<TextBox>
    <i:Interaction.Triggers>
        <i:EventTrigger EventName="KeyDown">
            <i:InvokeCommandAction Command="{Binding KeyDownCommand}"/>
        </i:EventTrigger>
    </i:Interaction.Triggers>
</TextBox>

Но если вы хотите там вызывать только обработку представления, например, запретить определённые клавиши (то есть, не нужны данные из слоя бизнес-логики), то есть смысл обработку сделать обычным способом - в code-behind (xaml.cs).

В целях оптимизации памяти стандарт языка C++ называет vector<bool> специальным стандартным контейнером, в котором каждый элемент bool использует только один бит памяти вместо того, чтобы занимать 1 байт, как занимает обычный bool. Ценой этой оптимизации является то, что этот контейнер не предоставляет всех возможностей и интерфейс, как это делает нормальный стандартный контейнер.

Т.к. мы не можем получить адрес отдельного бита в байте, такие вещи, как operator[] не могут вернуть bool&, а вместо этого возвращают прокси-объект, который позволяет манипулировать отдельным битом. Этот прокси не является типом bool&, вы не можете присвоить его адрес указателю с типом bool*, как вы могли бы сделать с "нормальным" контейнером. Это означает что bool &pb =v[0] не является валидным кодом.

bool& operator [] (int index) {
    return selfVector[index];
  }

должен стать

std::vector<bool>::reference operator [] (int index) {
    return selfVector[index];
  }

Почитайте про DI контейнеры

Тут два варианта: создать статический класс и в нем ссылку на экземпляр класса для работы с устройством и второй вариант — просто передавать требуемый класс в параметрах конструктора каждой VM.