The Lambda Calculus is interesting, elegant, and makes it much easier to understand functional programming languages. However, you won't encounter the LC in a typical CS Bachelor course, so you don't have to learn it right now – I would recommend to experiment with functional languages first before revisiting the Lambda Calculus. I believe OCaml is a good starting point into functional programming for a C programmer, and that Scheme is a good starting point to dive into the Lambda Calculus.
The Lambda Calculus is not associated with Calculus (which ought to be called Analysis instead). In general, a calculus is a “formal system”, i.e. a set of rules to do something. While Differential Calculus provides rules regarding the change of values, the rules of the Lambda Calculus describe computation itself. From this set of very basic rules, we can build arbitrary computations, data representations such as booleans, integers, or lists, and even control flow constructs such as conditionals or loops. The LC is equivalent to Turing Machines, but either model has different strengths.
Lambda Calculus had an immense impact on programming languages. The second high-level language to be implemented was Lisp, which can be understood as a direct encoding of the LC into a programming language. This “functional programming” has immense effect on the evolution of programming languages. Features such as anonymous functions, function pointers, closures (nested functions), garbage collection, variable scope, metaprogramming, advances in type systems, type inference, interpreted languages, dynamically-typed languages, object-oriented programming are all owed to a large part to the functional programming branch of programming languages. There's a joke that any new (non-academic) programming language only adds features that Lisp has already had for decades.
Beyond that, the Lambda Calculus and other related calculi are indispensable tools in programming language theory and in certain compiler construction techniques.
Any language that has anonymous functions which behave as closures and can be passed around freely immediately contains an encoding of the lambda calculus. Anonymous functions correspond a lambda expressions, except that in the LC functions always have exactly one argument. However, any Turing-complete language is equivalent to the LC, so the LC can always be implemented on top of such languages. This tends to happen in rule-matching systems or overly intelligent configuration formats, giving rise to “Greenspun's tenth rule” (in jest – mostly): “Any sufficiently complicated C or Fortran program contains an ad hoc, informally-specified, bug-ridden, slow implementation of half of Common Lisp.”