If a grammar is SLR(1), then: [Note 1]
The SLR(1) and LALR(1) state machines will have the same states
The set of shift transitions in the two machines will be identical (as will the goto actions).
The set of accept transitions in the two machines will be identical.
The set of reduction actions in the LALR(1) machine will be a subset of the set of reduction actions in the SLR(1) machine.
In other words, it is possible for there to be a reduce action in the SLR(1) machine which is an error (or unspecified) action in the LALR(1) machine. In the case of an input which triggers such a reduce in the SLR(1) machine, that input will still eventually trigger an error before another shift transition is taken.
The difference comes from the fact that the SLR(1) algorithm generates a reduction action for a state with a reducible item for any lookahead in the follow set of the LHS of that item. The LALR(1) algorithm only includes the lookaheads which are feasible in the context of the state.
For example, here's a simple grammar:
\begin{align*}
S &\to A \, [ \, A\, ] \\
A &\to \epsilon \, \mid \, ( \, A \, )
\end{align*}
The follow set of $A$ is $ \{ ) , [ , ] \} $.
Now consider any state in which $A$ follows the dot. For example:
\begin{align*}
A &\to ( \, \centerdot A \, ) \\
A &\to \centerdot \\
A &\to \centerdot \, ( \, A \, )
\end{align*}
This state has a shift action on $($ and a reduction action for $A \to$. It's clear that the reduction action should only be performed if the lookahead is $)$; any other lookahead is an error. But since $[$ and $]$ are in the follow set for $A$, the SLR(1) algorithm includes reduction actions for those lookaheads as well. The error will be detected after the subsequent goto action in the state $A \to ( \, A \, \centerdot \, )$. In the LALR(1) table, these two lookaheads will lead directly to an error.
However, there are other entries in the LALR(1) table for this grammar in which the LALR(1) parser will also execute reductions with a lookahead which obviously cannot be shifted. Only in an LR(1) parser are errors detected immediately. (That's not a good reason to use a canonical LR(1) parser).
Notes
- I take the view that if conflicting transitions are generated, then the construction algorithm fails and no parser is produced. That's the way the algorithms are described in Aho, Sethi & Ullman, for example (the so-called "Dragon Book"). If you take the equally valid view that a parser is always produced, but is not necessarily deterministic, then the following statements would be true for all grammars.
