Domanda

Ho programmato in C++ negli ultimi anni.Ma c’è una domanda che non sono riuscito a risolvere.Voglio chiedere, sono tutti temporanei in C++, rvalue?

In caso negativo, qualcuno può fornirmi un esempio in cui il temporaneo prodotto nel codice è un valore?

È stato utile?

Soluzione

No.

La specifica del linguaggio C ++ non fa mai un'affermazione così semplice come quella che stai chiedendo. Non dice da nessuna parte nello standard linguistico che "tutti gli oggetti temporanei sono rvalori". Inoltre, la domanda stessa è un po 'improprio, poiché la proprietà di essere un RValue nel linguaggio C ++ non è una proprietà di un oggetto, ma piuttosto una proprietà di un'espressione (cioè una proprietà del suo risultato). Questo è in realtà il modo in cui è definito nella specifica del linguaggio: per diversi tipi di espressioni dice quando il risultato è un lValue e quando è un rValue. Tra le altre cose, questo in realtà significa che è possibile accedere a un oggetto temporaneo come un RVALUE e un LVALUE, a seconda della forma di espressione specifica che viene utilizzata per eseguire l'accesso.

Ad esempio, il risultato del letterale 2 + 3 L'espressione è ovviamente un rValue, un temporaneo di tipo int. Non possiamo applicare l'Unario & A esso da unario & richiede un lValue come operando

&(2 + 3); // ERROR, lvalue required

Tuttavia, come tutti sappiamo, un riferimento costante può essere allegato a un oggetto temporaneo, come in

const int &ri = 2 + 3;

In questo caso il riferimento è allegato al temporaneo, estendendo la durata di quest'ultimo. Ovviamente, una volta fatto, abbiamo accesso a quello stesso temporaneo di un LVALUE ri, poiché i riferimenti sono sempre LValues. Ad esempio, possiamo applicare facilmente e legalmente l'Unario & al riferimento e ottenere un puntatore al temporaneo

const int *pi = &ri;

con quel puntatore rimane perfettamente valido fintanto che persiste il temporaneo.

Un altro evidente esempio di accesso a LValue a un oggetto temporaneo è quando accediamo a un oggetto temporaneo di tipo di classe tramite il suo this Pointer. Il risultato di *this è un lValue (come sempre accade con il risultato di unario * Applicato a un puntatore di dati), ma non cambia il fatto che l'oggetto reale potrebbe essere facilmente un temporaneo. Per un determinato tipo di classe T, espressione T() è un rValue, come esplicitamente indicato nello standard linguistico, ma l'oggetto temporaneo si accede *T().get_this() espressione (con l'ovvia implementazione di T::get_this()) è un lValue. A differenza dell'esempio precedente, questo metodo consente di ottenere immediatamente un LVALUE NON CONTRO-qualificato, che si riferisce a un oggetto temporaneo.

Quindi, ancora una volta, lo stesso oggetto temporaneo potrebbe essere facilmente "visto" come un rvalue o come un lvalue a seconda del tipo di espressione (che tipo di tipo Percorso di accesso) usi per "guardare" a quell'oggetto.

Altri suggerimenti

Prasoon Saurav ha già collegato un ottimo thread CLC ++. Lì, James Kanze spiega perché la domanda non ha davvero senso. Si riduce a:

  • la rValue -nessica è una proprietà (booleana) delle espressioni: ogni espressione è un lvalue o un rValue
  • i temporari sono non espressioni

Per questo motivo, la domanda non ha senso.

Un buon esempio è il seguente codice:

int main() {
  const int& ri = 4;
  std::cout << ri << std::endl; 
}

L'int temporaneo con valore 4 non è un'espressione. L'espressione ri Questo è stampato non è temporaneo. È un LVALUE e si riferisce a un temporaneo.

bene, quell'operatore di array restituisce un riferimento, qualsiasi funzione che restituisce un riferimento potrebbe essere considerata fare la stessa cosa?tutti i riferimenti sono const, sebbene possano essere lvalue, modificano ciò a cui fanno riferimento, non il riferimento stesso.lo stesso vale per il *operatore,

*(a temp pointer) = val;

Giuro che usavo un compilatore che passava valori temporanei a qualsiasi funzione che prendesse un riferimento,

quindi potresti andare:

int Afunc()
{
   return 5;
}

int anotherFunc(int & b)
{
    b = 34;
}


anotherFunc(Afunc());

tuttavia, non riesco a trovarne uno che ti permetta di farlo ora, il riferimento deve essere const per consentire il passaggio di valori temporanei.

int anotherFunc(const int & b);

in ogni caso, i riferimenti possono essere valori e temporanei, il trucco è che il riferimento stesso non viene modificato, ma solo ciò a cui fa riferimento.

se conti il-> come operatore, i puntatori temporanei possono essere lvalue, ma si applica la stessa condizione, non è il puntatore temporaneo che verrebbe modificato, ma la cosa a cui punta.

Un'operazione di indicizzazione dell'array è sia temporanea che un lValue, qualcosa come un [10] = 1 è un esempio di ciò che stai cercando; Il LVALUE è un puntatore temporaneo e calcolato.

Il codice del tuo metodo getView() è un casino, il metodo IT dovrebbe essere semplice come questo:

@Override
        public View getView(final int position, View convertView,
                ViewGroup parent) {
            View v = convertView;

            if (v == null) {
                LayoutInflater vi = (LayoutInflater) ctx
                        .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
                v = vi.inflate(R.layout.stacktest3_row, null);
            }
            final mapObject mo = items.get(position);
            if (mo != null) {
                ImageView imv = (ImageView) v.findViewById(R.id.selected);
                TextView one = (TextView) v.findViewById(R.id.mapname);
                TextView two = (TextView) v.findViewById(R.id.map_contains);
                TextView three = (TextView) v.findViewById(R.id.map_size);

                if (one != null) {
                    one.setText("" + mo.getMapName());
                }
                if (two != null) {
                    two.setText("" + mo.getMapContains());
                }
                if (three != null) {
                    three.setText("Size: " + mo.getMapSize() + "MB     POI: "
                            + mo.getMapContainsPoi() + "");
                }
                if (imv != null) {
                    imv.setImageDrawable(mo.getImage());
                } else {
                    imv.setImageDrawable(v.getResources().getDrawable(
                            R.drawable.cross));
                }

            }
            return v;
        }
.

Se si desidera una riga di elenco Fare clic su Ascoltatore, è necessario implementare il metodo onListItemClick(ListView l, View v, int position, long id) se si estende ListActivity o imposta un setOnItemClickListener() sull'elemento ListView se si estende Activity.Quindi nel metodo onItemClick():

@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
    mapObject item = l.getItemAtPosition(position);
            showDetails(item, context); //see what context you can use           
}
.

Quindi nel pulsante Seleziona:

select.setOnClickListener(new OnClickListener() {

    @Override
    public void onClick(View v) {
        //If you want to change the image then put your new image(or drawable or what ever) or id in the ITEM mapObject that you pass to the method showDetails() then call notifyDataSetChanged() on your adapter object
         alertDialog.dismiss(); 
        }
    });
.

SharePoint Designer fornisce una raccolta di azioni del flusso di lavoro disponibili tramite l'interfaccia utente del Designer Designer Workflow (UI). Sebbene la gamma di azioni del flusso di lavoro inclusa nel Designer SharePoint sia ampia, è comunque finita. In alcuni casi, potrebbe essere necessario modellare un processo aziendale i cui requisiti non sono soddisfatti dalla libreria esistente delle azioni del flusso di lavoro disponibili in SharePoint Designer.

Puoi dare un'occhiata ai seguenti collegamenti,

Le migliori pratiche per la creazione di personalizzate Attività in SharePoint 2010

Utili attività di flusso di lavoro personalizzato SharePoint Designer. -> In questo è possibile utilizzare il "Invia Email con attività di allegatura del file HTTP "-> Questa attività consente l'invio di e-mail con allegati recuperati utilizzando una richiesta Web. L'esecuzione del rapporto sui servizi di reporting e l'invio come allegato dal flusso di lavoro SPD sarebbe uno di questi esempi. Richiesta URL è completamente personalizzabile e può includere variabili del flusso di lavoro. Sono supportate sia le richieste HTTP che HTTPS. .

SharePoint 2010: creare un'attività del flusso di lavoro utilizzando Visual Studio 2010

Attività personalizzate Designer SharePoint per SharePoint 2010.

Come posso creare un'azione personalizzata per un flusso di lavoro?

Se no, qualcuno può fornirmi un esempio in cui il prodotto temporaneo nel codice è un LVALUE?

Il seguente codice lega un riferimento costante a un oggetto temporaneo di tipo const float Creato dal compilatore:

int i;
const float &cfr = i;

Il comportamento è "come se":

int i;
const float __tmp_cfr = i; // introduced by the compiler
const float &cfr = __tmp_cfr;
Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top